{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis of Python results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib import rc\n",
    "import pandas as pd\n",
    "# plot styles\n",
    "sns.set_style('whitegrid')\n",
    "sns.set_style({'font.family': 'Times New Roman'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"python-study-data.csv\", index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doi</th>\n",
       "      <th>filename</th>\n",
       "      <th>result2</th>\n",
       "      <th>result3</th>\n",
       "      <th>list_of_all</th>\n",
       "      <th>size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>doi:10.7910/DVN/8TB7GO</td>\n",
       "      <td>ei_preprocessing.py</td>\n",
       "      <td>TypeError: coercing to Unicode: need string or...</td>\n",
       "      <td>TypeError: invalid file: None</td>\n",
       "      <td>simulation_output.txt;format_cdc_data.sh;evalu...</td>\n",
       "      <td>274991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>doi:10.7910/DVN/8TB7GO</td>\n",
       "      <td>ei_preprocessing_india.py</td>\n",
       "      <td>TypeError: unsupported operand type(s) for +: ...</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>simulation_output.txt;format_cdc_data.sh;evalu...</td>\n",
       "      <td>274991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>doi:10.7910/DVN/8TB7GO</td>\n",
       "      <td>ei_preprocessing_ipums_census_acs_samples.py</td>\n",
       "      <td>AttributeError: 'NoneType' object has no attri...</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>simulation_output.txt;format_cdc_data.sh;evalu...</td>\n",
       "      <td>274991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>doi:10.7910/DVN/8TB7GO</td>\n",
       "      <td>ei_preprocessing_ipums_full_census.py</td>\n",
       "      <td>AttributeError: 'NoneType' object has no attri...</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>simulation_output.txt;format_cdc_data.sh;evalu...</td>\n",
       "      <td>274991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>doi:10.7910/DVN/8TB7GO</td>\n",
       "      <td>ei_preprocessing_race.py</td>\n",
       "      <td>TypeError: coercing to Unicode: need string or...</td>\n",
       "      <td>TypeError: invalid file: None</td>\n",
       "      <td>simulation_output.txt;format_cdc_data.sh;evalu...</td>\n",
       "      <td>274991</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      doi                                      filename  \\\n",
       "0  doi:10.7910/DVN/8TB7GO                           ei_preprocessing.py   \n",
       "1  doi:10.7910/DVN/8TB7GO                     ei_preprocessing_india.py   \n",
       "2  doi:10.7910/DVN/8TB7GO  ei_preprocessing_ipums_census_acs_samples.py   \n",
       "3  doi:10.7910/DVN/8TB7GO         ei_preprocessing_ipums_full_census.py   \n",
       "4  doi:10.7910/DVN/8TB7GO                      ei_preprocessing_race.py   \n",
       "\n",
       "                                             result2  \\\n",
       "0  TypeError: coercing to Unicode: need string or...   \n",
       "1  TypeError: unsupported operand type(s) for +: ...   \n",
       "2  AttributeError: 'NoneType' object has no attri...   \n",
       "3  AttributeError: 'NoneType' object has no attri...   \n",
       "4  TypeError: coercing to Unicode: need string or...   \n",
       "\n",
       "                                             result3  \\\n",
       "0                      TypeError: invalid file: None   \n",
       "1  SyntaxError: Missing parentheses in call to 'p...   \n",
       "2  SyntaxError: Missing parentheses in call to 'p...   \n",
       "3  SyntaxError: Missing parentheses in call to 'p...   \n",
       "4                      TypeError: invalid file: None   \n",
       "\n",
       "                                         list_of_all    size  \n",
       "0  simulation_output.txt;format_cdc_data.sh;evalu...  274991  \n",
       "1  simulation_output.txt;format_cdc_data.sh;evalu...  274991  \n",
       "2  simulation_output.txt;format_cdc_data.sh;evalu...  274991  \n",
       "3  simulation_output.txt;format_cdc_data.sh;evalu...  274991  \n",
       "4  simulation_output.txt;format_cdc_data.sh;evalu...  274991  "
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doi</th>\n",
       "      <th>filename</th>\n",
       "      <th>result2</th>\n",
       "      <th>result3</th>\n",
       "      <th>list_of_all</th>\n",
       "      <th>size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>310</th>\n",
       "      <td>doi:10.7910/DVN/NFZLI3</td>\n",
       "      <td>Transcripts_DTM_v1.py</td>\n",
       "      <td>NaN</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>88.VARADARAJAPURAM - SG.txt;5. KALKULAM - SG.t...</td>\n",
       "      <td>6698005</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>327</th>\n",
       "      <td>doi:10.7910/DVN/EEFBL5</td>\n",
       "      <td>replication_code_03_scrape_facebook.py</td>\n",
       "      <td>NaN</td>\n",
       "      <td>SyntaxError: invalid syntax</td>\n",
       "      <td>facebook_user_timeline.sqlite;meetup_mar15.sql...</td>\n",
       "      <td>46179335</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>328</th>\n",
       "      <td>doi:10.7910/DVN/EEFBL5</td>\n",
       "      <td>replication_code_04_scrape_facebook.py</td>\n",
       "      <td>NaN</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>facebook_user_timeline.sqlite;meetup_mar15.sql...</td>\n",
       "      <td>46179335</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>329</th>\n",
       "      <td>doi:10.7910/DVN/EEFBL5</td>\n",
       "      <td>replication_code_05_scrape_facebook.py</td>\n",
       "      <td>NaN</td>\n",
       "      <td>SyntaxError: Missing parentheses in call to 'p...</td>\n",
       "      <td>facebook_user_timeline.sqlite;meetup_mar15.sql...</td>\n",
       "      <td>46179335</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        doi                                filename result2  \\\n",
       "310  doi:10.7910/DVN/NFZLI3                   Transcripts_DTM_v1.py     NaN   \n",
       "327  doi:10.7910/DVN/EEFBL5  replication_code_03_scrape_facebook.py     NaN   \n",
       "328  doi:10.7910/DVN/EEFBL5  replication_code_04_scrape_facebook.py     NaN   \n",
       "329  doi:10.7910/DVN/EEFBL5  replication_code_05_scrape_facebook.py     NaN   \n",
       "\n",
       "                                               result3  \\\n",
       "310  SyntaxError: Missing parentheses in call to 'p...   \n",
       "327                        SyntaxError: invalid syntax   \n",
       "328  SyntaxError: Missing parentheses in call to 'p...   \n",
       "329  SyntaxError: Missing parentheses in call to 'p...   \n",
       "\n",
       "                                           list_of_all      size  \n",
       "310  88.VARADARAJAPURAM - SG.txt;5. KALKULAM - SG.t...   6698005  \n",
       "327  facebook_user_timeline.sqlite;meetup_mar15.sql...  46179335  \n",
       "328  facebook_user_timeline.sqlite;meetup_mar15.sql...  46179335  \n",
       "329  facebook_user_timeline.sqlite;meetup_mar15.sql...  46179335  "
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.result2.isnull()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convert dataset size to MB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['sizeMB']=df['size'].astype('int32').abs()/1000000\n",
    "df['sizeMB']=df['sizeMB'].round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Count files in dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_files_no(el):\n",
    "    temp = el.split(\";\")\n",
    "    return len(temp)\n",
    "\n",
    "df['files_count']=df[\"list_of_all\"].apply(count_files_no)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if there is documentation or readme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contain_docs(el):\n",
    "    temp = el.lower()\n",
    "    temp = temp.replace(\" \", \"\")\n",
    "    temp = temp.replace(\"-\", \"\")\n",
    "    temp = temp.replace(\"_\", \"\")\n",
    "    \n",
    "    if ('readme' in temp) or ('read.me' in temp): # avoid things like 'readdata'\n",
    "        return 1\n",
    "    if \"codebook\" in temp: # dataverse lingo\n",
    "        return 1\n",
    "    if 'instruction' in temp:\n",
    "        return 1\n",
    "    if \"documentation\" in temp or ('replicationdocument' in temp): \n",
    "        return 1\n",
    "    if '.md' in temp:\n",
    "        return 1\n",
    "    if 'guide' in temp:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['docs']=df[\"list_of_all\"].apply(contain_docs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if there is other code but Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contain_code(el):\n",
    "    \"checks if dataset contains other code\"\n",
    "    temp = el.lower()\n",
    "    if \".do;\" in temp or temp.endswith('.do'):\n",
    "        return 1\n",
    "    if \".r;\" in temp or temp.endswith('.r'):\n",
    "        return 1\n",
    "    if \".java;\" in temp or temp.endswith('.java'):\n",
    "        return 1\n",
    "    if \".cpp;\" in temp or temp.endswith('.cpp'):\n",
    "        return 1\n",
    "    if \".m;\" in temp or temp.endswith('.m'):\n",
    "        return 1\n",
    "    if \".sas;\" in temp or temp.endswith('.sas'):\n",
    "        return 1\n",
    "    if \".rb;\" in temp or temp.endswith('.rb'):\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['code']=df[\"list_of_all\"].apply(contain_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if there is a Dockerfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contain_docker(el):\n",
    "    temp = el.lower()\n",
    "    if \"Dockerfile\" in temp:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['docker']=df[\"list_of_all\"].apply(contain_docker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if there is requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contain_req(el):\n",
    "    temp = el.lower()\n",
    "    if \"requirements.txt\" in temp:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['req']=df[\"list_of_all\"].apply(contain_req)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if there is environment.yml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contain_env(el):\n",
    "    temp = el.lower()\n",
    "    if \"environment.yml\" in temp:\n",
    "        return 1\n",
    "    if \"environment.yaml\" in temp:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['env']=df[\"list_of_all\"].apply(contain_env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combine Py2 and Py3 results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_combined_result(r):\n",
    "    if 'success' in [r.result3, r.result2]:\n",
    "        return 'success'\n",
    "    if pd.isnull(r.result3) or pd.isnull(r.result2):\n",
    "        return np.nan\n",
    "    if \"time limit exceeded\" in [r.result3, r.result2]:\n",
    "        return np.nan\n",
    "    if r.result3:\n",
    "        return r.result3\n",
    "    if r.result2:\n",
    "        return r.result2\n",
    "\n",
    "df['result'] = df.apply(get_combined_result, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# turn TLE to NA\n",
    "def tle_to_na(el):\n",
    "    if pd.isnull(el):\n",
    "        return el\n",
    "    if \"time limit exceeded\" in el:\n",
    "        return np.nan\n",
    "    return el\n",
    "\n",
    "df['result2'] = df['result2'].apply(tle_to_na)\n",
    "df['result3'] = df['result3'].apply(tle_to_na)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggregate per dataset\n",
    "def aggregate(el):\n",
    "    if pd.isnull(el):\n",
    "        return el\n",
    "    if 'success' in el:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df['agg'] = df['result'].apply(aggregate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Success analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count success values\n",
    "\n",
    "success3 = (df['result3'] == 'success').sum()\n",
    "success2 = (df['result2'] == 'success').sum()\n",
    "success = (df['result'] == 'success').sum()\n",
    "total3 = df['result3'].count()\n",
    "total2 = df['result2'].count()\n",
    "total = df['result'].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "agg_df = df.groupby(['doi']).max(numeric_only=True)\n",
    "agg_success = agg_df['agg'].sum()\n",
    "agg_total = agg_df['agg'].count()\n",
    "\n",
    "values = [\n",
    "    success2*1. / total2,\n",
    "    success3*1. / total3,\n",
    "    success*1. /total,\n",
    "    agg_success*1. / agg_total\n",
    "]\n",
    "values = [(i*100).round(2) for i in values]\n",
    "\n",
    "totals = [\n",
    "    total2, total3, total, agg_total\n",
    "]\n",
    "\n",
    "labels = [\n",
    "    \"Python 2.7\\n\\n(a)\",\n",
    "    \"Python 3.5\\n\\n(b)\",\n",
    "    \"Combined \\n(best of two)\\n(c)\",\n",
    "    \"Aggregated \\nper dataset\\n(d)\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "      <th>totals</th>\n",
       "      <th>fail</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>24.01</td>\n",
       "      <td>379</td>\n",
       "      <td>75.99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>22.92</td>\n",
       "      <td>384</td>\n",
       "      <td>77.08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>26.91</td>\n",
       "      <td>379</td>\n",
       "      <td>73.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>43.96</td>\n",
       "      <td>91</td>\n",
       "      <td>56.04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   values  totals   fail\n",
       "0   24.01     379  75.99\n",
       "1   22.92     384  77.08\n",
       "2   26.91     379  73.09\n",
       "3   43.96      91  56.04"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_df = pd.DataFrame ({'values':values,'totals':totals})\n",
    "temp_df['fail'] = 100. - temp_df['values']\n",
    "temp_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr4AAAFVCAYAAAAJ7OypAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACBGElEQVR4nO3ddXgVx9fA8W8cSJAECMElEAju7hR3ipRCobRocXdKkaKF4lYcAkWDu0NxDRYgSAIhCcRd5/0jb/bHJSEEiEHO53n6lLsye3bv7Obc3ZlZPaWUQgghhBBCiG+cfkoHIIQQQgghRHKQxFcIIYQQQqQJkvgKIYQQQog0QRJfIYQQQgiRJkjiK4QQQggh0gRJfIUQQgghRJpgmNIBpFUPHz7kxIkTLFy4kKxZs1K7dm1tXnh4ONeuXaNEiRIsXbo0BaNMuJYtW1KpUiUmTZqU0qGIFGBvb8/du3e5du0a6dKlY/LkyRQrVuyDyzs7O7Njxw527drF1q1byZMnTzJGm7oFBgbSpEkTunfvTs+ePeNcxt3dXTt+f/75J1WqVElQ2ceOHWPjxo1cvnwZKysrbGxsePv2Laampvz44480a9bsi2K/evUqO3bs4O7duxw4cOCLykotEruufuq5ktTc3d05evQoCxYswN/fn+bNm/PDDz9QuXJlQkNDOXDgACtXruTZs2eUK1eOn376iebNm6dYvJ8iId/d+fPn2bZtG0eOHCFz5syUKlWKLFmy4O3tjY+PD+XLl6d79+7kzZs3BfZAJAVJfFNIsWLFKFasGJs2bSJ//vzMnDlTZ76Xlxdz5sxJoeji5+LiQubMmcmUKZM2rVq1ahQtWjQFoxLv8vHxISAgIFkSysOHD7N161a2bt1KYGAg3bt3Z9++ffH+MTcxMSEoKIg3b9580rbCw8N5+vRpsta1e/fuUaJEiWTbnomJCdWrV6dw4cI609897/T09DA2Nubly5efVHbDhg0xNDTk8uXLDBgwgA4dOhAVFcX48eMZOnQonp6e/PTTT59U5rvHJ3v27Dg5OREcHPxJZaRmn1tX4/I550pSy5EjBz/99BM3btzg4MGDTJkyBTMzMyB639u1a0dwcDBTpkyhb9++1K1bN8Vi/VQJ+e5q1qyJpaUlR44coXPnzgwdOlSb9+TJE0aNGsWOHTuYMWMGTZs2/aTtJ/e1QySMNHVIYenTp49zuoWFBfXr10/maBJm7ty5+Pn56UwbN24c33//fQpFJN63cuVKXr16lSzb2rJli5Zgm5qasmPHDkaOHBnvOjly5PisP/bbtm3j3r17nxXn5zhz5gwnT55Mtu0BGBoaMmvWrFgJxrvnnaWlJSVLlvys8jNkyKDzWV9fn5EjR2JgYMDff/9NZGRkgsvy8PBgyZIl2ucCBQpQqFChz4ortfrcuhqXzzlXkouJiQkA6dKlizUv5u+UsbFxssb0pRL63b1/TsQoXLgwGzZsIHv27IwZM4bHjx8neNvvnxsi9ZDENxVr2LBhSocQy+LFizl8+HBKhyHisXPnTtasWZNs23N1dcXQ8NMfHunrf9rl5/z588yYMeOTt/O5Hjx4wIgRI5Jte/GJ67z71OMXHwsLC8zNzQkICMDX1zdB6/j4+NC3b1/8/f2TLK7UIrH26XPPFfH5vvS7MzMzY9CgQYSEhPDPP/8kaJ0PnRsidZAzMBUKDw9n1apV/PbbbwDcuHGD2bNnc/PmTapXr86iRYu4ePEiQ4YMoU+fPvTv3x8DAwMA7OzsePbsGc7Ozri6utK/f3+aNGmilb13716uXbtGZGQk9+/f56effqJdu3acOnWKuXPn8uTJExwdHVFKsXPnTv78809KlCjBxo0bOXPmDJcvXwZg/vz5mJqa8vvvv3Pq1Cm2bdtGtmzZ+PPPP7VtXblyBXt7ezJlysSdO3coXLgww4cPJ3PmzLi7u7Nr1y52797NH3/8wZ07d1i3bh1GRkbMmjWLatWqffD4bNiwAU9PT/z9/dm7dy8dOnSgd+/e7Nmzh1mzZtG6dWtmzpyJi4sLa9aswc7OjhkzZtCuXTsAAgICWLJkCVFRUTx//pywsDAmTJiAtbV1guZ7enqyZs0aAgICcHBwwMrKirFjx2ptwOKKb/To0R+d9y4PDw/s7e3ZuXMn48aNY8uWLdy4cYO1a9eSNWtW5syZQ548eXj58iXPnz9nwoQJlCtXjlu3bnH8+HGUUqxdu5YDBw4wdOhQzM3N+e+//zh58iReXl48fPiQZs2a8dtvv33wD0NkZCT//PMPb968ISQkhAcPHvDDDz/QoUMHAP777z8OHDjA27dvuXnzJuPHj6dkyZJ07tw5zvJevHjB33//TbZs2fDw8CAoKEhnvr+/PzNnziRz5sz4+/tz+/ZtBg8eTIMGDXj69Cl79+4lPDyc3bt3c+vWLXr06EHu3LmZP38+oaGh6Ovrc/nyZbp166bFGBYWptXVp0+fcvjwYZYsWUK9evWA6EeR9vb2+Pr6cv/+fapWrcrw4cPx9/dn165d+Pn5cerUKd68eUPbtm0pW7YsixcvBuD169fs37+fUaNG0bVr11j7e/DgQSZOnEhUVBT//PMPBQoUYNmyZWzcuJFy5coxceJESpQowZ07dxg4cCDNmjVjyJAhHDp0iO3bt1OtWjUGDBgQ53k3ZcoUbTtKKRYvXszGjRtJnz49s2fPpnLlynF+Bx/i7++Pl5cXWbNmxdjYmEGDBnHkyBEKFizIrFmzKFOmDIC2nblz53Lz5k08PDwAmDRpEuXKlaNt27ZamW5ubkycOJErV65QsWJFFi1apN1Z+1jdunr1Krt27cLBwYHVq1czefJkLl68SJkyZViyZIn2KD4ud+7cYceOHRgYGODg4EClSpUYPny4lnA+fPiQDRs2kDlzZu7fv4+FhQWjRo0iZ86cWhkfq6vAJ51PHzpXihYtyo4dO3BwcGDKlCkMGzaMnDlzYmdn99FjdP36dW3ddevWMW3aNM6ePUuBAgVYuHAh/v7+TJ48mQcPHlC5cmUWLFiAqanpJ9WL+MR3vvr6+rJv3z527tzJjz/+yK1btzh06BDDhw/n4MGDXLt2jcaNGzNhwgQsLS1xcXFh8uTJZMmShUmTJqGvr//JZc+bN4+6desm6Lv7VPXq1UNfX59jx44xa9YsALZv387ly5fJmTMnFy5coHz58owbNw6Ivs7HdW6cOHGCffv2kT9/fi5fvkzevHn5448/yJAhA//88w8LFixAX1+fefPm0aBBAwD27NnD9OnTmTt3LrVr1yYoKIiVK1cSEBDA3bt3MTExYcyYMdja2nLjxo0P1qd9+/bh6OhIREQE+/fvp3z58ixcuBAg3jK/SUqkqHr16qkaNWqoiRMnqokTJ6oxY8aounXrqtGjR+ss5+fnpxo0aKAaN26sQkJC1Jo1a9S2bdt0llm8eLE6ePCg9nnRokWqWLFi6ubNm0oppdavX68GDx6szf/rr7+UjY2NunfvnlJKqb///lvZ2NjolPnjjz+qrl27ap937typbGxslIuLi1JKqdDQUHX79m1VsmRJnZivXr2q6tSpo/z9/ZVSSgUFBalmzZqp9u3bq8jISPXmzRu1efNmZWNjo0aOHKmuX7+u3NzcVLNmzVSLFi0+eLxu376tfvvtN+3z9evX1cyZM7XPderU0YnD2dlZ2djYqJ07dyqllAoLC1Pt27dXp0+fVkopFRUVpWrVqqVatmyZoPkhISHql19+UT4+Pjr71axZMxUVFRVvfB+L/V2urq5q8eLFysbGRg0ePFhduHBBjRo1Srm4uKju3burYcOGact26NBBdejQQft86dIlZWNjoy5duqQzberUqdrny5cvKxsbG7Vy5coPHuuJEyeqKVOmxCp348aNOsvVq1cvVn19n4eHh6pRo4a6fPmyUkqpyMhI1b17d526NG7cONWpUydtnSFDhqjq1atrn11cXHS+S6WUWrJkiapRo4b2ec6cOcrW1lYFBgYqpZRatWqVWrdunTZ/2bJl6uTJk0oppZ48eaKGDBmioqKilFJKvXjxQhUvXlz9/vvv2vI2NjZq4cKF2ueDBw+q6dOna5/37t0b63i8a/HixapEiRLKz89PKRVdnxo1aqTz/YWHh6v+/fsrpZTy9/dXZ8+ejbXd9887pf73fYwYMUJdu3ZNvX79WjVp0kS1a9fug/G8u17M9SM8PFyNGTNGFS1aVO3evVub1qJFC9WxY0eddffs2aNWrFihfe7atavO9UEppUaPHq0qVaqkVq5cqVxdXdWxY8eUjY2N2rRpk7bMx+qWq6ur6ty5s6pcubJasWKFev36tTp9+rSysbFRa9as+eC+3b59WzVp0kT7/s+dO6dsbGzU2rVrlVJKPX/+XFWrVk25urpq+/nzzz+revXqqYCAAKVUwurq55xPSsU+Vx48eKDatm2rqlSpov755x+1bds2NWvWrAQdo0ePHqm2bduqypUrqw0bNih3d3d17do1VaJECdWlSxe1du1a5e7unqDjplT092ZjY6PCw8NjzYupfxcuXNCmxXe+enh4qO3btysbGxv1888/qwsXLqhx48YpBwcH5enpqUqXLq3mzp2rs40hQ4ao4ODgLyo7Id9dXGKuLfPmzfvgMlWrVlU2NjbK29tbXb16VdnY2KinT58qpZQ6c+aMsrGxUWfOnNGWf//cePnypbK1tVXnzp1TSkVff2xsbJSdnZ22zMyZM1WJEiW0v5tKRf8t/eeff7TPffr00fYlIiJCde/eXVWvXl35+/t/sD65ubmp77//XivD2dlZDR8+PEFlfovkjm8qkDdvXp07OC9evGDt2rU6y2TMmJHZs2fTtWtXxo0bF+uuT0hICKtWraJ79+48efIEAF9fXypWrMjz588pVqwYf//9NytWrNDW6dq1KxYWFuTLlw+I+5HQxx4TGRsbU7p0aczNzXWmz5kzh1q1aml3ZtKnT0+/fv0YPnw4+/fvp1WrVhQsWBCAtm3bUr58eQBq167Nxo0bP7g9Dw8P/vvvP44fP853331H+fLlCQsL+2C8enp6Op8PHTqEl5cXderU0ebPmDGDwMDABM93d3dnw4YNWpmFCxfGy8sLb2/veOP7WOzvypkzp3ZMWrRoQfXq1alevToANWrUwMbGBoi+25ctWzYePXr0wWMGsGTJEiwtLVm0aBEAUVFRVK5cGU9PzziXf/r0Kf/++y9btmzRplWpUoWaNWsyf/582rdvH2dbwA9ZtGgR2bNn1+5E6uvr07hxYy5evKgtU6FCBSpUqKB9zpo1K15eXvGWW6JECbp3766zTmRkJL6+vmTIkAF3d3fOnTtHtWrVsLGxoXPnzri6ugLwzz//EBQUpN3BjdnH+B5Puru7c/DgQRo1akTFihVp1qwZN27c+ODyHTp0YOnSpRw4cIAffvgBPT09ihUrxtGjR/Hy8sLCwoLTp09rT2XMzMzifdoRl3bt2mnHrW7dujrfWXxOnz7N69evcXZ2Jn369NjZ2Wl1ztDQkN9++40hQ4Zw584dSpcuDcD+/ftjdcSNS4YMGejVqxcQXZezZMmiXZcSUrdy5sxJnjx5cHV1pXfv3gBYWVmRJUsWnj59+sHtzp8/n+bNm2t3lqtUqcLEiROpWbMmAAsWLKBYsWLa3V1DQ0MGDRrEDz/8wIYNG+jXr1+C6uqnnk8fUqxYMQoXLoyrqyvdu3fX7kon5BgVKVKEQoUK4ePjo3VItLS0xNbWFj09PX7++WdtWvbs2eM9bu8aP358rOvmixcvYi0X3/maPXt2baSRunXr6ly/IHoUoF27djFw4ECMjY15+vQp+fPn164pn1v2pEmTPvrdfa6YYxIVFUWOHDno0KGD9rcza9asAPFer8zMzGjdurV2LsW1zk8//cT69evZuXOndl3bs2eP1g786tWr3L9/n927d2vrWFpaEhkZyatXrz5Ynx48eMD9+/fZtm0b7du3J2/evLRv3z5BZX6LndYl8U2F8ufPH+cjhvLly9OrVy+WL1+OnZ2dzrwnT54QHBxMly5dsLS0jLWug4MDgYGBOgmqpaWldnH8Uu+2WwsICODWrVs6Fy6AsmXLAnD79m1atWqlJanvJqsZMmQgPDz8g9upXbs25cuXp3///pQoUYJevXp9Uk/bW7duxUrSa9SokeD5Dg4O5MiRg4EDB35yfJ8ae8xxyZgxo870Xr164eXlxcqVKwkKCsLHx4eoqKh499vBwYGpU6fSokWLeJeL8d9//wHojNwB0d/h+fPnefLkySd1rjpx4oSWVMWI6UwTo127dgQEBGjNQV6+fPnR/apTpw7VqlVj+/btuLi44ObmBqB10OrWrRunTp2idevW1K1bl99++41SpUoBcPfuXVq0aEGfPn0SvB+tW7dm7969dOnShcqVK9OvXz+dP+jvs7S0pE6dOuzYsYMffviBV69eaT8Gd+7cSa9evTh27BhTp07V1vnUNqDvnj/p06cnJCQkQevVrVtXe2wel8aNG1OgQAFWrFjBkiVLcHZ2JmPGjFhYWHxSTBB9XsfEldC6pa+vH6scU1PTeK8Pt27d4rvvvtM+GxkZ6TRDuXDhAlWrVtVZp1SpUhgYGHD79m0gYXX1U8+n+Ojr65MhQwad7z2hxyiuuhLXD1JjY+N4j9u7pk+fHqvcXbt2xfqB97HzNSZRfP/6BdC9e3e2b9/OgQMHaNu2Ldu2bdP5W/S5ZSfku/scgYGB+Pj4kDlzZszNzbGwsGDatGmcO3eOy5cva8crvutV5syZmTFjBrdu3eLkyZNkzpw51jq5cuWiYcOGbNq0iZ9++gkvLy9MTEy0euDg4ED69Ok/+PcH4q5Ptra2tG7dmokTJ7J69Wp+/fVXrTN6Qsr81nx7vRC+EZ06dYpzur+/P9bW1kyePFnnbmFERAQQ3b7tfV5eXiilAOLslfr+CA2JJaaNU4yYhPxLOncYGxuzevVqFi9eTHh4OEOGDGHixIkJXj8qKooXL17E+iMQEhJCWFjYR+eHh4fz8OHDWHdqAwMDCQkJiTe+L409xvHjx+nbt6/WJjTmrkN8IiIitD/s7/rQHYqY+vL+d5g9e3bg07/DmD8c8bl+/To//fQTlSpVYujQoQkaBsjJyYlOnTqRJ08ehg0bFiupyZs3LwcOHGDkyJHcunWLjh07smfPHiC6Lf2nHBMAc3Nztm/fzvTp03n16hU9evRg+fLl8cbYsWNHHBwccHR0ZMOGDQwaNIhGjRrx77//8vLlS7Jnz55oveX19PS07+5L6evr07NnT06cOMGTJ0/Ytm3bB69LnxJXYtetd0VFRWl3lt/17jXu/e0aGhpiYWGhbTchdfVTz6dPlZTHKLF8zvkao0iRItSoUYP169cTGBhIQEAAVlZWX1x2Qr67z3Hu3DkiIyNp0KABenp6BAUF0atXLx4+fMjw4cO1u6fxiYyMZOzYsezfv5+BAwfy66+/xrlc9+7dcXZ25uTJk/z7778651xERASvXr2K9WQhMjLyo/s9Y8YMNmzYgIWFBRMnTqR3794opb6ozK+VJL6pWGBgIPb29trn3bt3U7JkSRYsWMDz58+ZN2+eNs/a2hojIyMWLFigM4bmkydPuHTpEoUKFcLY2Jh169bp/MJ8+PAh169fB/43VM27d4wiIyPj/KUdHzMzM2xsbLh06ZKWkAN4e3sDaM0IPsfFixfx8/OjYcOG7Nmzh59//plt27ZpPdGNjIx04o+JPeb/xYsXx8/Pj23btumUu2nTJvT09D46v2jRorx9+zZW796Y+fHF97HYEyIoKIjhw4fTunXrD47RG9d3VLRoUbZt28bz58+1acHBwezcuTPOMsqVKwdEX/Df5e3tTc6cObWmFgllbW3N3bt340wMYv7IDx8+nKpVq36wQ0Vc+zVp0iTy5s37weYBhw8fxsTEhF9++YWjR49SoUIFVq9eDUQfk5MnT3Lt2jVt+cjIyHibChw7dgyA9u3bc/jwYZo2bcqqVas+uDxE3+nPmTMnK1asIDIykhw5ctC5c2dcXFwYPXp0gv5oJuS8SwqtW7cme/bsLFmyhNu3b39yp7m4JHbdepetrS179uzh7du32rSAgADtx065cuW4e/eudi2C6GuDj4+Pdl1KSF391PPpUyXlMUosHztfP6Z79+48ePCACRMm0KZNm0QpOyHf3acKDg5m0aJFmJqaah3OV61ahYODA7169Urwubl792527drFsGHDMDIy+uBy5cuXp3Tp0qxZs4YXL15QpEgRbV7RokUJDw/X+dsP0Xfk43vS8/jxY5ycnKhSpQpbtmxh7NixnD9/ngcPHnx2mV8zSXxTWGhoqE5yGCMiIoIJEyZoj2UfPnzIjRs3aNeuHUWKFGHgwIGsW7dOeySWMWNGunbtyqNHj+jYsSPr1q1jxYoVzJgxg++++w4zMzO6devGrVu36NWrF/b29ixbtoy//vpLa/9WoEABIDqJe/ToEStXrsTDw4OXL1/i6OhIVFSU1iv4yZMnXLhwQWsPGRERoTP+54gRI3j79q1Ok4w9e/ZobbJi1oG4Hw/FdUwg+o7KsmXLgOg7Uq1atSJ79uzao6CCBQty+fJlbt++zaVLl1i3bh0Q3cbp1atXtGjRgrx58zJjxgz++usv7O3tGT16NEZGRhgZGX10fuvWrcmdOzcLFixgxIgRbN26lYkTJ6Knp4eJiUm88X0s9vfFHJfQ0FCdaWFhYRw+fBhnZ2cOHDjA3bt38fX15c6dO7i6uup8R/fu3cPFxYV+/foREhJCp06dtJ75vXv3plGjRnFuu2TJkjRr1oydO3dq4wHHbHfUqFE6j6BDQkI+2nO6b9++BAUFMXLkSN68eUNAQAAXLlwAokct8fT0JCQkhHPnzuHk5MTp06e1+bdv38bR0VFrt/nkyRNevnyJg4MDISEh3Lhxg3v37nHlyhUOHToEwKNHj7h9+zYXL17k9OnTQPQ50qBBA210jp49e2JoaEjPnj2ZM2cOdnZ29O7dW+ctaKampjg5OeHl5cWlS5d49uwZW7duBaJ/KDZr1kwr70P09fX5/vvvOXz4sNYWs2LFihQpUgRDQ0PtvIsRU/ffPZ/iOu/e/1EXVxlxifljlpDe7sbGxvz8888cPHhQ62X+LlNTU16+fIm/vz8nTpzQ4o4vpoTWrfDw8E/et379+hEUFESXLl3YsmULdnZ29OnTRxsTeciQIQA6d+kPHTpE4cKFad26NZCwuvqp51OMuM6VqKgonXP8U47R+9fdmPLeP25KqY+OzxxzwySu4xsT37txfux8jUk039+3GLVr16ZQoUI8e/aMihUr6sz73LIT8t3Ft+/vc3V1pWfPnrx584Zly5ZpI/eEhITg4+PDoUOHePTokdbn49WrV9rf5PfPjZhYt23bxrNnz1i+fDl6enq8fv061g+c7t27c/369Vj1qVatWpQqVYodO3bQu3dvtmzZwsyZM3F0dNTumMdVnwIDA1m0aJF23Nq0aUP69OnJlStXgsr85qRAhzqhonvzzpw5U9nY2ChbW1s1ePBgNXr0aDV69Gg1ZMgQ1aBBA9W2bVullFLXrl1TtWvXVmPHjlURERFKKaVWrFihbGxsVOXKlbXe2ZGRkWrRokWqZs2aqnz58qpfv37K3d1d22bM/OrVq6uKFSuqESNGKE9PT21+eHi4Gjp0qCpVqpTq3Lmzevr0qerRo4caOHCgOn36tIqKilL+/v6qa9euqnLlymrLli0qLCxMbdiwQRUtWlTVrFlTGw1BKaWOHTum2rRpo/r3768mTZqkZs+erUJCQpRSSj19+lQNGDBAG7XA0dFRXbp0SbVu3Vrr0e7l5RXruO3fv1/Z2Niorl27qvnz56sJEyao+/fv6xzXxo0bq3Llyqk///xTPXv2TNWoUUPNnTtXvXjxQiml1KtXr1SfPn1U6dKlVYMGDXR6mydk/suXL1Xfvn1VmTJlVN26ddXy5ctVZGTkR+P7WOzvcnR0VP3799eWv337tjZv5cqVqkKFCqpRo0Zq3759ys7OTpUrV07rbR8REaEGDhyoypcvrzMywKFDh1SzZs1UqVKlVPv27bXRPj4kJCREzZw5U7Vo0UJNmDBBjRo1Sh07dkznOMybN0/Z2NioihUrqh07dqjnz59/sLx///1X1a1bV5UqVUr169dPLV26VLVs2VJt2rRJ+fv7K3t7e1WlShVVp04dtW7dOnXy5ElVtmxZNXXqVO34Tp06VZUrV05NnDhRRUREqPPnz6vatWuratWqqXnz5qnbt2+rcuXKqaFDh6rg4GA1ceJEVbx4cTV06FC1cOFC9fvvvytvb28tpkuXLqnvv/9elSxZUrVo0UIb8SHGihUrVIUKFdRvv/2mgoKC1IoVK1TRokVVnz591MKFC9WECRPi7S0ew9XVVWckB6WU2rhxozpw4IDOND8/P7VgwQJlY2OjWrRooa5du6aUUrHOuydPnsQ6fy5evKidP4sWLVK+vr6x4jhy5Ijq2rWrVv7+/ftVUFBQvLH7+/ur6tWrayOZvOu///5T1atXV61atVJPnz5Vx44dUzVr1lS2trZq48aN6s2bN2rTpk2qePHiOteHj9WtEydOqBo1amjlvH37Vqec48ePfzDew4cPqyZNmqgyZcqorl27aqPWxLh69arq1KmT+uWXX9Qff/yh/vjjj1j79rG6qtSnnU8fOlcOHTqkatasqWxsbNSCBQt0rscJPUbFihVTGzduVH5+fmr79u2qbNmyqnz58mr79u3K19dXrV69Wtna2qpatWrFedzc3NzUli1bVMWKFZWNjY2aOHGiunLlihbD/v37VZs2bZSNjY364YcftDob3/nq7OysJk6cqNWz//77L87jYmdnp7Zv3x5r+peUnZDv7l1nz57VzqUaNWqogQMHqvHjx6tBgwapLl26qEWLFsX6W/Tq1SvVtm1bVb58eTVkyBD1+vVrVb9+fdWuXTvl7OyslIp9bvj7+6tu3bqpsmXLql9//VW9ePFCderUSTVq1Eg5ODjolB8eHq46d+6sXffe5e3trUaOHKnKly+vatSooWbMmKFCQ0OVUuqD9enmzZvKxsZGtW3bVv31119q4sSJ6uLFiwkq81ukp1QiNQgTQgjxzXn9+jWLFy9m+vTpKR2KEEJ8MWnqIIQQ4oPs7Ow+u1ObEEKkNsneNfTIkSMMGjRI+7xixQrq1q3LjRs32LlzJ5kyZcLY2JghQ4akWIcOIYRIy+zt7Tl37hz58uXD1dVVG3tUCCG+dsma+CqlOH36tPZyBj09PapVq8br168ZNWoU9vb2mJmZMW/ePFasWEHfvn2TMzwhhBCgDadUv359nRflCCHE1y5Z2/geP36cCxcuMHDgQJ1B0KdNm0ZgYCAzZswAosei/eWXX7hw4UKiDD4thBBCCCFEst7x3bFjB+fPn2fLli20b9+eMWPGYGZmxoULF3TegFOoUCH8/f1xcHCINczJu27cuCHNIYQQQgghhEZPT097W+z7kjXxXb58OSEhIRw5coQZM2bg6urK6tWrcXNzI0uWLNpypqam6Onp4e7uHm956dOn/+zBs4UQQgghxLfnwYMHH5yX7J3b0qVLR+vWrSlSpAjt27fHwcFBmx5DKYVSCgMDg+QOTwghhBBCfKNSbDiz4sWLU61aNV6+fImVlZXOu9Rj/v3NvjVECCGEEEIkuxQdx9fQ0JBSpUpRu3ZtnJyctOnOzs5kzpyZkiVLpmB0QgghhBDiW5Jsia+3tzdbt27V3hN/5swZypQpQ968eenSpQtXrlwhPDwcgKNHj9KzZ08MDZO9JYYQQgghhPhGJdtwZq9eveLXX38lMDCQSpUqUbt2bdq0aaPNP3PmDCdPnsTCwgJ9fX0GDBjw0REbHjx4IJ3bhBBCCCGEJr78MFnH8U1skvgKIYQQQoh3xZcfpmgbXyGEEEIIIZKLJL5CCCGEECJNkMRXCCGEEEKkCZL4CiGEEEKINEESXyGEEEIIkSZI4iuEEEIIIdIESXyFEEIIIUSaIImvEEIIIUQSGTlyJD///DMArq6utGzZEjMzMypUqMC9e/fiXCckJISBAwfSq1cv6tevz9KlS2MtExAQwIIFC/jzzz85e/aszvZ69OhBrVq1OHHihM46gYGBVKtWjbdv3ybeDn5lJPEVQgghhEgC58+fZ968eQBERkYyZswYKlWqRJEiRbhx4wYDBgyIc71x48axePFi5syZw/Dhw+nfvz/btm3T5j958oRq1aphZWXFuHHjqF27NgD79u1j7ty5/PDDD1hZWdGpUyeioqK09caMGcOwYcPIli1bEu516iaJrxBCCCFEIgsMDGTkyJFa4unm5saSJUuYNGkSBw4cAKLv7MZl06ZNAGTKlIlKlSoBsGDBAgCCg4Np3bo1lSpVolOnTjrrOTo6AmBsbEz69Onx9PTEx8cHgLNnz+Lh4UGHDh0Sd0e/MpL4CiGEEEIksilTptC7d2/tc+7cucmYMSMA7u7uZM6cmblz58a5bmhoKABv3rzBwsICgNu3bwOwYsUK7t+/z7NnzyhevDg9evTA398fgLp166Kvr4+3tzc+Pj5UrlwZCwsLgoKCGD16NIsWLUqy/f1aSOIrhBBCCJGIjh07RuHChSlYsGCseTt37qR9+/YEBQVx48aNONevX78+ALt37yYoKAgAQ0NDALZs2QLAypUr6dWrF+vWrWPMmDEAVKxYkcOHD+Po6EiFChW0O8vjx49n8ODBWFhYMHv2bGbMmMGpU6cSd6e/EpL4CiGEEEIkEl9fX7Zt20avXr3inF+xYkVq165NeHg4w4YNw83NLdYyy5cvp3PnzsyfP5+OHTsCULRoUeB/zRmMjIxo3bo1APb29tq6DRs2ZOzYsfz+++9ky5aNCxcu4OLiwg8//MDo0aNZv349tWrVomHDhty6dSsR9/zrIImvEEIIIUQimT59OgCTJ09m3bp1ANy6dYvTp08DkD9/ftauXUvbtm2JiIjg+fPnscrIkSMHdnZ2ODo60qRJEwAtAQ4PDweiE+xcuXIB4OnpGWcswcHBjBw5kiVLlgCwefNmsmbNipWVFZGRkWzdujVR9vlrIomvEEIIIUQi8fDw4J9//uGPP/5g/fr1QHT73JjEN0bXrl0xMDCgcOHCKKXYsWMHTk5OOsuEhYWxbNkyChcuTN++fQEoXbq0th0jIyMAChcuHGcsEydOpH///uTIkQNAazahrx+d/n2oc923TBJfIYQQQohEsm7dOpRSKKW0drTdu3cnffr01KlTBxcXFyA6cR08eDDZsmXj4MGDdOjQgc6dO2vlREZG0qdPHyIiItizZw+mpqYADBw4EICbN29q4/HG1azi0qVLODk50aVLF21anTp1CAgIwNfXF4juDJfWGKZ0AEIIIYQQ3zpra2uePXtG2bJl6dKlCzY2NsyZMwcAGxsbcuTIQbVq1QDYs2cPu3fvplixYsyfP58sWbJo5fz44494eHiwefNmHj16xLhx4xg0aJDOtkJDQxk2bBg7d+7Umb548WJ69OjBwoULGTlyJG3atEnSfU6N9JRSKqWD+FwPHjzA1tY2pcMQQgghhBCpRHz5oTR1EEIIIYQQaYIkvkIIIYQQIk2QxFcIIYQQQqQJkvgKIYQQIlWIjPhqux2JRJSU9UBGdRBCCCFEqmBgqMeOlbHfZCbSlva9rZKsbLnjK4QQQggh0gRJfIUQQgghRJogia8QQgghhEgTJPEVQgghhBBpgiS+QgghhBAiTZDEVwghhBBCpAmS+AohhBBCiDRBEl8hhBBCCJEmSOIrhBBCCCHSBEl8hRBCCCFEmiCJrxBCCCGESBMk8RVCCCGEEGmCJL5CCCGEECJNMEypDU+bNo2AgABmzpwJwI0bN9i5cyeZMmXC2NiYIUOGoKenl1LhCSGEEEKIb0yK3PE9fvw4x44d0z6/fv2aUaNGMXbsWEaPHo1SihUrVqREaEIIIYQQ4huV7Inv69evuX37NtWqVdOmrV69mkqVKmFmZgbAd999xz///ENoaGhyhyeEEEIIIb5RyZr4RkZGsnLlSgYMGKAz/cKFC+TJk0f7XKhQIfz9/XFwcEjO8IQQQgghxDcsWdv4/vPPP/z000+YmJjoTHdzcyNLlizaZ1NTU/T09HB3d4+3vNDQUB48eJAUoQohhBAimdna2qZ0CCKVSKr8LtkS34sXL5IzZ04KFSoU5/x06dJp/1ZKoZTCwMAg3jJNTEzkJBFCCCGE+MZ8SX4XX9KcbInvihUruHv3LlOmTAEgJCQEiO7oZmVlhZ+fn7ZszL+trKySKzwhhBBCCPGNS7bEd86cOTqd1WbPng3AqFGj2LhxI05OTto8Z2dnMmfOTMmSJZMrPCGEEEII8Y1LtsQ3e/bsOp8zZMgAQJ48eejSpQs9e/YkPDwcIyMjjh49Ss+ePTE0TLFhhoUQQgghxDcmVWSW+fLlY/z48UybNg0LCwtMTEzo1atXSoclhBBCCCG+ISmW+Ma8sS1GnTp1qFOnTgpFI4QQQgghvnUp8uY2IYQQQgghkpskvkIIIYQQIk2QxFcIIYQQQqQJkvgKIYQQQog0QRJfIYQQQgiRJkjiK4QQQggh0gRJfIUQQgghRJogia8QQgghhEgTJPEVQgghhBBpgiS+QgghhBAiTZDEVwghhBBCpAmS+AohhBBCiDRBEl8hhBBCCJEmSOIrhBBCCCHSBEl8hRBCCCFEmiCJrxBCCCGESBM+OfENCwvDy8uL8PDwpIhHCCGEEEKIJGGYkIWeP3/O+vXrOXPmDK9fvwZAX1+fwoUL07hxY7p27UqmTJmSNFAhhBBCCCG+RLyJr1KK+fPnc/nyZapUqcKAAQPImjUrxsbGhIaG4uHhgaOjIz169KBPnz40atQoueIWQgghhBDik8Sb+P79999UrFiRYcOGxVuIUgp7e3tOnDhBgwYNEjVAIYQQQgghEsMH2/jevn2b9u3bU7t27Y8WoqenR9u2bcmUKROBgYGJGqAQQgghhBCJ4YN3fMuUKfPBlZ48eUJoaCgFChTA1NRUm16pUqXEjU4IIYQQQohEkqDObTFevXpF79698fT0xMjIiLCwMMaNG0fr1q2TKj4hhBBCCCESRbzDmTk6Oup8PnbsGGvXruXSpUucO3eO06dPc+/evSQNUAghhBBCiMQQ7x3fM2fOcO3aNbp06QJED2G2d+9eihQpgrGxMa6urvj6+iZLoEIIIYQQQnyJeO/49u7dm2LFijF58mS8vLzo0qULERERLFiwgKlTp3L9+vWPjvgghBBCCCFEavDRNr4VKlTAxsaGBQsWULt2bfr27Uvfvn2TIzYhhBBCCCESTYJeWZwxY0YmTJjA27dvmT9/PmFhYUkdlxBCCCGEEInqo4lvVFQUPj4+ALRr1462bdvy+++/4+TklNSxCSGEEEIIkWjiTXyPHz9OtWrVqFatGi1atOD169cUKFCAqVOncuDAAbZu3ZpccQohhBBCCPFF4k18z58/z969e7lz5w5z587lyJEjABgaGjJo0CDy5cvH77//niyBCiGEEEII8SXi7dxmaGiIiYmJ9v+oqCid+dWrV8fW1jZJAxRCCCGEECIxxJv4VqlShYYNGxIQEIC1tTUrVqyItYy5uXmSBSeEEEIIIURiiTfxbdiwIXXr1sXX15ds2bIlV0xCCCGEEEIkug+28b1+/TpOTk4YGRklOOk9fvw4QUFBiRacEEIIIYQQieWDiW+FChU4ffq01qEtPkFBQcyfPx9zc3MyZMiQqAEKIYQQQgiRGOJt6vDrr7+yfv16GjduTPny5bG2tsbc3BwDAwOCgoJwc3Pj0aNHuLu7M23aNEqUKJFccQshhBBCCPFJPvrK4u7du9OsWTP+/fdfjhw5wtOnTwkNDcXCwoKSJUvSpEkTWrZsiYGBwUc3du/ePSZOnMizZ88oW7YsM2fOJEeOHADcuHGDnTt3kilTJoyNjRkyZAh6enpfvodCCCGEEEIAekoplRwbCggIYO3atXTp0gUPDw/69u1L5cqVmT17Nq9fv+ann37C3t4eMzMz5s2bR4YMGejbt2+8ZT548ECGUxNCCCG+ITtWuqV0CCKFte9t9UXrx5cffvSVxYnF0NCQAQMGYGFhQbFixWjatKl2l3j16tVUqlQJMzMzAL777jv++ecfQkNDkys8IYQQQgjxjftoU4fEki5dOp3PPj4+DBo0CIALFy7QokULbV6hQoXw9/fHwcGBihUrfrDM0NBQHjx4kDQBCyGEECJZyVNcESOp8rtkS3xj3L59m3Xr1vH06VN8fX3JmTMnbm5uZMmSRVvG1NQUPT093N3d4y3LxMREThIhhBCaixcv8ttvv+Ho6Ejjxo1Zs2aNzouWrly5wvbt26lQoQK1a9cmV65cOuuHhIQwcuRIQkJCcHJyon379vz222/afKUUu3bt4s8//2Tnzp0UKFBAmzd//nzOnz+Pv78/PXr0oHPnztq8qKgoGjZsyNKlSylatGjSHQAhvhFfkt/FlzR/UuKrlMLb2xsLCwsCAgK0pgmfIl++fLRs2ZL58+fTs2dPjh8/DujeEVZKoZRKUIc5IYQQAsDT05NffvmF7NmzExoair29Pebm5qxZswaAadOmcfToUfbu3atzs+Vd48aNY/HixXh7e2tPI7Nly0bHjh158OAB8+fPZ9WqVbHWu3PnDsOGDWP58uU8efKEn3/+mQYNGmBpaQlEJ8VNmjSRpFeIFJbgNr53796lfv36jB49GgBXV1emTp2Kp6fnJ23Q3Nyc+vXrs3TpUjw9PXn06BFWVlb4+flpy8T828rqyxo3CyGESDvu3LnD+fPnOXv2LPPmzQPg0qVLAKxfv57Jkyezfv36Dya9AJs2bQIgU6ZMVKpUCYAFCxYA0XegVq5cSc6cOWOt9+jRIwCMjY1Jnz49YWFhvHz5EoDHjx+zf/9+hg0bljg7KoT4bAlOfP/44w+aN2+OjY0NADY2NtSsWZPx48d/1obz5s2Lubk5uXLlonbt2jg5OWnznJ2dyZw5MyVLlvyssoUQQqQ99erVI2vWrAA0atQIgKJFixIeHs7IkSPJkiULvXr1omLFiuzbty/OMmI6Vb958wYLCwsguoneu4yNjWOtV6VKFTJkyIC3tzc+Pj7ky5eP4sWLExUVRb9+/Vi6dKk8xRQiFUhw4luyZElGjBihPbaB6DZLV69eTdD6AQEB3L17V/t85coVvvvuO7Jly0aXLl24cuUK4eHhABw9epSePXtiaJjsTZCFEEJ8A168eAFA3759OX78OG/evKFx48bY29vj5uZGhw4dcHFxibVe/fr1Adi9ezdBQUEACfpblDdvXk6fPk1AQABZs2blzJkzpEuXjkWLFvHdd99ha2vLihUrtLbBQoiUkeDMMuZXdMxLJYKCgli+fDlFihRJ0Pr37t1j8ODB5MmThwoVKpA9e3YmTZoERLf7HT9+PNOmTcPCwgITExN69er1qfsihBBCAGBnZ8cvv/xC48aN+fvvvwEwMjLCzMyM+vXrs3HjRg4fPhzrb83y5ctJnz498+fPx97eHiDB7XIrVaqkNY8AcHJyYvfu3Zw4cYJFixYxbtw47t27R/78+dmzZw+tWrVKlH0VQiRcghPfpk2bMmTIEPz8/Hj8+DGnTp0iMjKS1atXJ2j9KlWqaG2t4lKnTh3q1KmT0HCEEEKIOF25coUXL15w5MgRAO1poq+vL4A2kkNcfVRy5MiBnZ0dAH///TdHjhyhY8eOnxyDUop+/fqxZMkSDAwM2Lx5s9a8D6ITc0l8hUh+CU58ra2t+fPPPzl9+jSurq6MGjWKunXrkilTpqSMTwghhEiwgIAA5syZg729PenSpeP+/ftERUUB4OHhAUTf+QUoXLgwSil27txJuXLlsLa21soJCwtj2bJlFC5c+KNvEY3LkiVLqFOnDiVKlADQmk3o60e3MAwJCfn8nRRCfLYEJ752dnb8+OOPNGvWTJvm5OTEuXPnaN68eZIEJ4QQQnyKvn37cuzYMWxtbVFK4eXlhaurKxs2bODu3buEh4fz9u1bcufOTbNmzTh48CAdOnSgUqVKXLlyBYDIyEj69OlDREQE+/btw9TUVGcbEREROv9/37Nnz9i+fTsnTpzQptWpU4fNmzdrd53r1q2bBHsvhPiYjya+165dQynF7du3sbGxQSmlzfPx8WHWrFmS+AohhEhxy5YtY/PmzcD/mjXkyZOH7Nmzc+DAAXr27Em/fv1wdXXl4MGDZMiQARsbG3LkyEG1atUA2LNnD7t376ZYsWLMnz9fZ+gzV1dX9u3bx+vXrwFYvHgxgwYNolChQtoyMU0cFi1apNMpbsqUKTx9+pRRo0bRvXt3nZdiCCGSj556N5ONw61btxgxYoQ2HuG7jIyM6NixIxMnTkyyAOPz4MEDeXObEEII8Q3ZsdItpUMQKax97y97j0N8+eFH7/iWLVuW9evXc+DAAXr37v1FgQghhBBCCJFSEjSOb+7cufn1119jTXdxcUnwOL5CCCGEEEKkpAR3bnv+/DlbtmwhKChIa+cbGhrKtWvXOHv2bJIFKIQQQgghRGJI8JvbRo8ezYsXL7T3kUP0Hd+uXbsmSWAi4S5evEi5cuXIkCEDbdu2xdvbO9YyI0eO5Oeff/5gGYcOHaJz5878+OOPzJw5M9b8EydOUL9+fc6cOaMzfcuWLTRu3Jh27doxf/78WOt17tyZ06dPf/I+CSGSV9gHRigQaYvUA/GtS/Ad3xo1ajB06FBu3rxJZGQkFStW5PXr12zdujUp4xMf4enpyS+//EL27NkJDQ3F3t4ec3Nz1qxZoy1z/vx55s2bx08//RRnGc+fP6ddu3YcPnyYYsWKYWVlRe7cufnpp59wcXFhyZIlzJkzh6ioKO1texD9LvsePXowdOhQ8uTJw4ABA6hXrx5ly5YFYNeuXWTNmlWG7RHiK2BsaEijtctTOgyRwo72+PQxi4X4miT4jm9gYCDu7u6UK1eOgwcPEhYWRlRUFDt27EjK+MRH3Llzh/Pnz3P27FnmzZsHoPOGvMDAQEaOHKkN4B6XNWvWEBISgqWlJTly5ABgxYoVQPT752fOnEmVKlVirffixQtCQ0MxNjYmffr0ADx9+hSITshnz54d591jIYQQQoiUkODEt0SJEtSvX5+LFy/SrFkz6tSpQ7NmzciXL19Sxic+ol69emTNmhWARo0aAbrvlZ8yZcpHR+O4ePEiAMbGxtq0q1evEhkZqX1+d14MW1tbrKys8Pb2xsfHh0yZMlG9enUABg8ezPTp0zEzM/vMPRNCCCGESFwJbupQpUoVrly5or3B5t9//8XR0VFLdETKe/HiBYD2es1jx45RuHBhChYsGO96r169AsDAwECbFhYWhqenJ5aWlh9cz9TUlLNnz7JhwwaCgoI4d+4cVlZW7NmzBzMzMxo0aMC2bdt4/PgxlpaW9OrV60t3UQghhBDisyX4jm+7du3Yu3ev9jlfvnw0bNgw1qscRcqxs7Pjl19+oXHjxvj6+rJt27YEJZvv3tl910febQJAkSJFmDp1KhMmTKB06dJ4e3szY8YM5syZw759++jUqRM9evRg0KBBLFy48JP3SXw9PtTJMiGdLwFCQkIYOHAgvXr1on79+ixdulSbFxERwaBBg7CwsCB//vyx+haMHDmSHj16UKtWLZ3XxEJ0c59q1arx9u3bRN5jIYQQX5sEJ75NmzaNs51nzGNykbKuXLnCixcvWLJkCQDTp08HYPLkyaxbtw6IfgtfXCMs5MqVC9BNdE1MTLQmFJ9i8ODBTJ06lYwZM2qvDrWysiJr1qzY2dl9cnni6xDTyTJjxoxaJ8vhw4d/cHpcxo0bx+LFi5kzZw7Dhw+nf//+bNu2DYBp06Zx9epVTE1NcXZ2plu3bjg5OQGwb98+5s6dyw8//ICVlRWdOnXSadM+ZswYhg0bRrZs2ZL+QAghhEjVEtzUISIigoEDB1K6dGltWlRUFBcvXpRxfFNYQEAAc+bMwd7ennTp0nH//n0cHR117tAD3L59m9OnT1O3bl0OHTpErly5KFOmDNWrV+f06dOEhIRoy1asWFHnPfMJsX//fkxMTGjYsCEAQUFB2jx9fX2d8sW3JaaTZdasWVmwYAFDhgzh0qVLH5wel02bNgGQKVMmKlWqBMCCBQvo2LEjJUqUYPLkyfj7+1OyZEmcnZ25fv061tbWODo6AmidLD09PfHx8cHCwoKzZ8/i4eFBhw4dkudACCGESNUSfMfX19eXnDlz6twV1NfX13rzi5TTt29fjh07hq2tLTly5KBMmTKsW7cOpRRKKU6dOgVA9+7dmTx5Mvfu3aNZs2Zagvrrr7+SPn16Xr58iY+PD0CsDnER/z+2Y8QHxnj08fFh2rRp/PXXX9q0OnXqANGJuZ+fnwxr9g37UCfLj3W+fFdoaCgQPUyehYUFEP1jDdAS14wZM1K1alWdcurWrYu+vr7WybJy5cpYWFgQFBTE6NGjWbRoUaLvrxBCiK9Tgm/pde/enVKlSsXq3e/g4JDoQYmEW7ZsmdakwNfXF4A8efJgbm7+wXVy5cpFoUKFtLv3hQoVYseOHSxZsgQjIyNmz55Nt27dAPDy8uLIkSPcunULiB76zMrKipIlS+qUOXToUCZPnkymTJm0aQMGDODWrVsMHz6c2rVrM3ny5MTabZGKvd/J8mPTY9SvXx97e3t2797Njz/+CBDnU4cXL15QtWpVypQpA0Q/nTh8+DDXrl2jQoUK9O/fH4Dx48czePBgLCwsmD17NpGRkVStWpV69eolzo4KIYT46uiphPRgSqUePHiAra1tSochhHhHt27dMDIyYvXq1QmaHsPd3Z2hQ4dy/fp1ChYsyJEjR6hcuTKXL1/WlnFycqJcuXJcvnw53nP/woULzJ8/nx07djB8+HAOHz7MihUrqFu3LteuXdNesiJ0yQssRGp4gcWOlW4pHYJIYe17W33R+vHlhwlu6iCEEB/zfifLj01/V44cObCzs8PR0ZEmTZoA0LFjR51lhg8fzsaNG+NNeoODgxk5cqS2rc2bN5M1a1asrKyIjIyUt00KIUQaJomvECJRxNXJ8ubNmx+crpRix44d2ugMMcLCwli2bBmFCxfWaRaxatUqWrRoQevWrVFKsWXLljjjmDhxIv3799feQhjTyVJfP/pyJ50shRAi7ZLEVwiRKOLqZFmgQIEPTj948CAdOnSgc+fOWhmRkZH06dOHiIgI9uzZo40TfufOHYYNG8aECROwsrLC3Nw8ztEhLl26hJOTE126dNGm1alTh4CAAK0NvHSyFEKItCvBndsOHjwIRL/BLTAwkAkTJqCUYvLkyVhbWydZgElJRUSg94lDdolvj9SDL/ehTpZbt279YOdLGxsbcuTIQbVq1QDYs2cPu3fvplixYsyfP58sWbIA4O/vz/fff09AQAABAQHaNt8dWhGiR4UYNmwYO3fu1Jm+ePFievTowcKFCxk5ciRt2rRJ9P0XQgjxdUhw57b69euzcOFCSpYsSYcOHQgPD2fQoEGcO3eO33//PanjjFNidG57PWVxIkUjvlY5Jw1I6RCESBWkc5uQzm0iNUjKzm0Jvs3VqVMnSpYsyZkzZ7h37x779u3D2to6Vvs8IYQQQgghUqMEt/ENCAjgzp07zJw5k++//x5ra2uCg4M5dOhQUsYnhBBCCCFEokjwHd82bdqwaNEiKlSowNixY3F2dmbNmjXaG5aEEEIIIYRIzRKc+FpbW/P3339rn/Plyydv4hIiEUREhGFoaPzxBcU3TeqBEEIkvQQnvqtWrcLIyIiWLVvy6tUrhg4dilKKOXPmUKFChaSMUYhvmqGhMX8tldfopnXDfzuV0iEIIcQ3L8FtfPft20fz5s0xNzdn1KhR5M2bl2XLlnH48OGkjE8IIYQQQohEkeA7vq1atSJ79uzs27cPV1dX1q1bh5WVFVmzZk3K+IQQQgghhEgUCb7j6+XlxcGDB5kzZw7du3fHysqKt2/fsmvXrqSMTwghhBBCiESR4MS3R48e3Lt3j86dOzNkyBCcnZ1Zu3at9tYlIYQQQgghUrMEN3XInj07I0aMwNvbGwMDAywsLBg5cmRSxiaEEEIIIUSiSfAd37t379KgQQPGjBkDgKurK1OnTsXT0zPJghNCCCGEECKxJDjx/eOPP2jWrBlFihQBwMbGhpo1azJ+/PgkC04IIYQQQojEkuDEt2TJkowYMQJLS0ttWlRUFFevXk2SwIQQQgghhEhMCW7jGzNsmZ6eHgBBQUEsX75cuwOcELdu3WLKlCk8e/YMW1tbJk2aRLFixQC4ceMGO3fuJFOmTBgbGzNkyBBtW0IIIYQQQnypBCe+TZs2ZciQIfj5+fH48WNOnTpFZGQkq1evTtD6AQEBrFq1ijFjxqCnp8eMGTPo3bs3R48exdvbm1GjRmFvb4+ZmRnz5s1jxYoV9O3b97N3TAghhBBCiHclOPG1trbmzz//5PTp07i6ujJq1Cjq1q1LpkyZErS+k5MT06dPJ0uWLADMmjWLFi1a8PjxY/bs2UOlSpUwMzMD4LvvvuOXX36hR48emJiYfPpeCSGEEEII8Z4Et/EFePz4Mc2aNaNnz57kyZOHyMjIBK9bpkwZLekFyJs3L/r6+lhZWXHhwgXy5MmjzStUqBD+/v44ODh8SnhCCCGEEEJ8UILv+M6ePZu1a9dy/PhxcufOTenSpZk0aRKdOnWiTJkyn7zh69ev07JlS7Jnz46bm5tOUmxqaoqenh7u7u7xlhEaGsqDBw8+edsxbG1tP3td8W35knr0paQeihhSD0VqIPVQpAZJVQ8TnPjev38fe3t7cufOHb2ioSGdOnVi8uTJ7N69+5M2qpRi586dOkOhpUuXTme+UgoDA4N4yzExMZGTRCQKqUciNZB6KFIDqYciNfiSehhf0pzgpg61atWiaNGiOtOcnZ159erVJwe0du1aevbsqY0UYWVlhZ+fnzY/5t9WVlafXLYQQgghhBBxSXDiq6enx6FDhwgMDMTb25tdu3YxZcoUGjRo8Ekb3LNnDyVKlKB48eLatNq1a+Pk5KR9dnZ2JnPmzJQsWfKTyhZCCCGEEOJDEtzUoXv37ixcuJDx48cTHByMkZERbdq00V5hnBA7duwgPDyc3Llz8/LlS3x9fbl69SpdunShZ8+ehIeHY2RkxNGjR+nZsyeGhgkOTwghhBBCiHglOLM0MDBg6NChDB06FC8vL8zNzT/pBRN2dnb88ccfsabPnz+ffPnyMX78eKZNm4aFhQUmJib06tUrwWULIYQQQgjxMQlOfF+9esXKlSsZOXIkFhYWXL58GXd3d1q1apWg9X/88Ud+/PHHD86vU6cOderUSWg4QgghhBBCfJIEt/EdM2YMDg4OREREAFClShV8fHxYvnx5kgUnhBBCCCFEYklw4lukSBF27dqlM95u2bJl2bhxY1LEJYQQQgghRKJKcOJrYWERa9revXtJnz59ogYkhBBCCCFEUkhwG99KlSrx22+/Ub16dcLCwjh16hRXr15l5syZSRmfEEIIIYQQiSLBiW+VKlXImjUrdnZ2vHz5koIFCzJ06FDKly+flPEJIYQQQgiRKD5poNzChQszadIk7XNkZCQ3btyQ5FcIIYQQQqR6CU58x44dG2ual5cXxsbGkvgKIYQQQohUL8Gd227fvh1r2tu3bzE3N0/UgIQQQgghhEgKCb7jO2vWLEqVKqUz7caNGzx58iTRgxJCCCGEECKxJfiO7/tJL0CxYsVYunRpogYkhBBCCCFEUvjsNr5RUVHcv3+fDBkyJHpQQgghhBBCJLYE3/G9ceOGzmdDQ0Pq168vb24TQgghhBBfhQTf8Z0xY4aM3iCEEEIIIb5aCU583016z5w5w/Pnz6lVqxaFChVKksCEEEIIIYRITPEmvm3btkVfX5+aNWvSunVrChUqxOzZs1m7di0ZMmRg8eLFLFmyhMqVKydXvEIIIYQQQnyWeNv4Pnz4kP79+zN06FAKFSrE3bt3Wbt2Ld999x0XL15kz549rF69OrliFUIIIYQQ4rPFm/hWrlyZ+vXra5//+usvsmTJwp9//omxsTG5cuUiR44cSR6kEEIIIYQQXyrexLdgwYLav8+cOcPFixcZMGAAGTNm1Kb7+PgkWXBCCCGEEEIklnjb+Pr7+2tj9f7+++8ULVqUzp07a/OdnZ05d+5ckgcphBBCCCHEl4o38R06dCj9+vXj8ePH5M+fn4ULF6Kvr8/Lly85cOAAGzduJCQkJLliFUIIIYQQ4rPFm/jmyZOHffv24eXlhbm5OXp6egDkypWLHj160KNHj2QJUgghhBBCiC+VoHF8LSwsdD7r6+tjbGycJAEJIYQQQgiRFBL8ymIhhBBCCCG+ZpL4CiGEEEKINEESXyGEEEIIkSZI4iuEEEIIIdIESXyFEEIIIUSaIImvEEIIIYRIEyTxFUIIIYQQaYIkvkIIIYQQIk2QxFcIIYQQQqQJkvgKIYQQQog0QRJfIYQQQgiRJkjiK4QQQggh0gRJfIUQQgghRJogia8QQgghhEgTJPEVQgghhBBpgmFyb9DR0ZGVK1dibW3Nb7/9pk1/+vQpq1atwsLCgtDQUEaNGoWxsXFyhyeEEEIIIb5RyXrHNygoCB8fHy5fvkxkZKQ2PTAwkN69ezNw4EBGjhxJkSJFmDp1anKGJoQQQgghvnHJmvhmyJCBKlWqkC9fPp3p27dvJ2fOnOTKlQuA7777jp07d+Lm5pac4QkhhBBCiG9Ysjd1ADAwMND5fP78efLmzat9zpo1KxkzZuTy5cu0bt36g+WEhoby4MGDz47D1tb2s9cV35YvqUdfSuqhiCH1UKQGUg9FapBU9TBFEt/3ubm5YWNjozPN1NQUd3f3eNczMTGRk0QkCqlHIjWQeihSA6mHIjX4knoYX9KcKkZ10NPTI126dDrTlFKx7gwLIYQQQgjxuVJF4psjRw78/Px0pvn6+mJlZZVCEQkhhBBCiG9Nqkh8a9eujZOTk/bZ09OTkJAQqlatmoJRCSGEEEKIb0mKJL5KKZRS2uc2bdrw/PlzfHx8ADh69Cjt27cna9asKRGeEEIIIYT4BiVr57aoqCiOHTuGk5MTkZGR1KxZk/Lly5MpUyYWLFjAnDlzyJkzJ/7+/kyYMCE5QxNCCCGEEN+4ZE189fX1ady4MY0bN441r3Tp0pQuXTo5wxFCCCGEEGlIqmjjK4QQQgghRFKTxFcIIYQQQqQJkvgKIYQQQog0QRJfIYQQQgiRJkjiK4QQQggh0gRJfIUQQgghRJogia8QQgghhEgTJPEVQgghhBBpgiS+QgghhBAiTZDEVwghhBBCpAmS+AohhBBCiDRBEl8hhBBCCJEmSOIrhBBCCCHSBEl8hRBCCCFEmiCJrxBCCCGESBMk8RVCCCGEEGmCJL5CCCGEECJNkMRXCCGEEEKkCZL4CiGEEEKINEESXyGEEEIIkSZI4iuEEEIIIdIESXyFEEIIIUSaIImvEEIIIYRIEyTx/cZERUWl6vJE2hAVpVJ1eSJtUIl8/Urs8kTa8Dl/R5WSa15SMUzpAETiCA4PY9G5YzSzLcMdVxf+PnsY/5BgulWqydjvWgGw6NxRZhzfp7NeOkMjHEbNwEBfn6lH7QmNCOeF91uaFy/Lz5Vr4+LjxabrF+hfsyFZ0mdIiV0TX5HwsEhOHHWmVJlsvHQJ4Pih54QER1KtVi6atS4EQGhIBPt2ORERqUif3hCvt8G0+8GGzFlMdMry9Qll7rSrDB1bARMTA04edaFWvdxkMU+XErsmviKRYWE8O3CEHBXK4vfcmaf7DhIRHEyeerUp8n0bAJ4dOMKTnfY66+kbGVFnwWz0DAx4vG0XUeHhBHm8IUfF8uStX4fgt568OnOeAs0aYWRqmvw7Jr4qoWHB7D68iMplm3D99jFeezzFP9CbIgXL06HFcPT09LRlHR6cY+ehBXRoMYwSNtWJiAjj371zqFOtA3lzFU3Bvfj2yB3fb0BkVBS/bFlF5XyFcPHxxOG1Cw1tShIYFsqic8e4+PwxANddnqOnp0fmdOkxz2BKOiMjahaywdTEhJkn9rH2ylkmNmpDn+r1GXdgO3vv3iC/RTZalSxP5w1LCA4PS+E9FalZVJRi7cq7FLTOjLdXCK9c/CleKhuhoZGcPOqM02MfAPbtduLShde0aV+Y1u0L4+oayO5tj2OV9++mhwQHRwBgamZM7fp5WLX4Dv7+Ug/Fh6moKG4vWo55EWuC33ri98KZ7GVLExkayvMDR/ByfASAr9NT0NPDMEN6jMxM0Tc2wsK2KIbp0vFk5x5cTpymSMd25G/8HQ83bcXtynUyWGYnR+WK3PhrEZFhUg/Fh0VGRTJnWQ9sC1fm4ZMrbNs/l5aN+tGt/e9s3/8Xe48uBeCt1ys27ZrO1AU/cM/xAvz/jV4jIxPatxjG/FV9eeUW+/ooPp8kvt+A5f+d5LWfD3UL21I4Ww5mtOjI9OYd6FSuKgChEdHJQ6GsljwYM4sHY2dzb/RM6hW2pXGx0gDsvHMVgIwm6SibKz8A/1w6DUCpnHnJaJKOme/dLRbiXWdOuODrHUpRWwssc2SgXScb2nYsQqVqVgBEhEc/7nv6xBeA166BAJiZGeH5NlinrEvnXXnp7K8zLXMWE/IXzMTOLY+SelfEV+zFkeOEePuQtWRxTHNaYftTZ4p16USuGtUBiAqPvh5msLKk7qK/qLd4HnUXziVbyRJkL18GgNcXLwNgmC4dmQtGXw+dj58EIFP+vBimj06OhfiQ/ceW4+n9mjLF63L28k4AMqTLSJ6cNpgYp+fgydUAZLPITdd24ylSsHysMtKZZKB6xZYsWN1fmj4kIkl8v3JhEREsPX+MSvmiHyMXyW6lzXsT4E/LEuWoXSj6McmEhq3IlC49ACHh4Zx7+ohGRUtq5QB4BgVoTRruu7/SyqpesAjrr57HMzAg6XdKfHUiIqI4dcyZAtaZAbC0+t9j4AC/MMqUz06RYuYA5M2fEQC7dfdxeeHHW49g6jTIqy3v+TYYz7fBWOWK/SjZ2iYLd2+/xfWV1EMRW1REBM8PHiVLYWsATHP+73oY5udHjkoVyFq8GABF2rfFKEP09TAyPBzP+w/JXib6RoD6/+thmH8Ahv/fpCHA5X/XQ/NiNricOkuYv9RDEVt4RBj2R5ZQ1LoSABER0U8H/AI80dPTwzRDFrx8XuMX4KmtY2hoFGdZJYrW4JmzA9fvHEv6wNMISXy/chdfPME7OIgCFtm1ae7+vozZ9y9HHR1w8vTAMyj64qyv/7+v+4zTQ4pZ5iS7WSYAahS0AeDQgztakwZDfQNt+YJZsxMWGcHxR3eTfJ/E1+fpYx+CAiPIlj29Ns3PN5SdWx5xz8GTN+5BBAaEA9CmfWHyFciIt1coC+fcoHjprFSsEp2gREUpThx+wXdNC8S5nWzZo3+UOdx6k7Q7JL5K3o6PCQ8MJEOO/10PQ318ebDBjje37hDo5q4lq3rvXA89797HLE8uTDJHXw/Ni0XfLPC4cYuo/2/S8O7yGXJYoiIieHvbIcn3SXx97j+6SECgNzktCwJQsmgNAC7fPERUVBTh4SEAGOh/vJtVTsvom1qXbh5IomjTHkl8v3KPPF4DYGb8v45BWTOYUdu6KNnNMnLf7RXzzxyOtd7hh3e0Zg4As1p2ok2pCqy8eIo+29cCYJ3VUptvZhzdoeihu2uS7If4urm9jm62YGLyvx9LpmZG2NiakzGjEa6vAjl26DkAenp6ZM2WnrIVouvX9cvunD/9EoALZ15RqVpOnXLeZZIuerrb/zeTEOJdAa+ir08G6f53PTTKaIZFCVuMM2UiwOUlz/YdjLXem5u3sSxXRvts2+1HrKpUxPnoCe4s+weADFY5tPkG6aKvh/4vXyHE+166OgKQLp0ZAJ1ajaZh7W5cuXWI2ct64B/oTeaM2TDNkPmjZaVPF/3EwfnVg6QLOI2RxPcrFxgWCoCx4f9+ORoaGNCseFk2de2Hvp4ez73e6qwTFRXF8Ud3afJO4pvdLBNL2//M+UETqVfYFoCWJcpp803+v3z/0JAk2xfx9QoLjQTA0PB/lxQDA31Klc1Oz/6l0dMDzzfR7Xi3rH/AMydfuv5SnEbNCwBw+rgLQYHhXPnvNY8eenHkwDO8PaPr2rlTL7UyjYyiyw8JiUyO3RJfmcjQ6Ouh/juPjfUNDMhRoRzlhg4APT2CPHSfFqioKN7cdiD7O4mvSeZMlOrzKzVm/EHWksUByFGpgjbfwCj6ehgZItdDEVtIaPQPcyNDYyA6ee3dZRYLp5ynfo0fAKhWoVWCyjIyjP6RFRwizWoSiyS+X7nM6aIf/YZGhMeaVypnXopa5qRwthw606+6PMUigxnW2SxjrRMWEcH6q+cpaJGdbpVqatND/r/8jOnSx1pHiPQZohON8IjY41XmzpsRq5ymWFpF19VHjt7a0GX1vsuHkZE+oSGRhIRE8No1kGMHX3Ds4Au8vaKTmHOn/ndXLTwsuvx06eK+IyzSNqMM0XUsKjz29TBT/ryY5c6FqZXu9dDniRPGZmaxpkN0m+GXp86S3jI7eevV0qZHhkWXb5herociNtMMWQAIDw+NNe/giX/IaGpOu2aDElRW2P83i8iQLmOixZfWSeL7lSuZMw8AfiHB+AQHUXvRNNZcPgNAeGQkekDvavV01jn84A6Ni5aKVVZkVBSj9m0lMiqKtZ17keGd5hMxd3pLWOVOoj0RX7PceaMf6YUERRAUFM7sKVe05guRkVGgB7XqRXdgy5svI95eISil0DfQw8BQj5JlsmGRNT1zl9TV/itUJPox4LgpVbTthIREdzrKlccsOXdPfCUy5o+uYxFBQYQHBvLf+D9wPnEagKiI6KcE+Ro10FnH48Ztnbu9MVRUFA/W26Gioig7sB8GJv+7HkYER18PzfLmSYrdEF+5gvmiO40HBvnqTN+6ZxbOrg8Z2W8N5pl1f2hFRkZf2yKjInSmB4dEj26TP2+JpAo3zZEXWHzlKuQpQO7M5jz19MDE0JD85lmZfmwv++/dokp+a5a2/5k8WSx01jni6MDi77vrTDv88A6HH9zGOlsO/mjSjszvvazi6VsP0hkZ0dCmZJLvk/j65CuQiSzmJrzxCMLIUB+LbOk4sOcpd26+oWDhzHTpURyLrNGP7H7oZsuufx+xfbMjBob6lK+Ug+b//3KLj3njEYyeHpQpl/3jC4s0J3OhgqTLakGguwf6Rkakz56Nx9t34371BuY21pTq8yvps2XVWefNrTuU6tVDZ5rHzdt43LiFqZUVNp3ba3eSYwS5u6NvbET2srFvIAhRpGAFslnkxtXjKQAOD89z8fo+zEyz8NekkzpJr3+gN7fvneb5y3sAnLywlSyZLMmXO3r0EVd3JwCqV2iZzHvx7ZLE9yunr6/PqPrNmXF8HyYGhmzs2u+j6/w3+PdY05oUK63T5vd9F58/oW/1BrESYiEA9PX1aNKyIAf3PMXAUJ+ev324LllkTRfv/Bi/DSkXa5rTYx/KV8qhM1yaEDH09PWxbtOSJzvt0Tc0pNyQ/h9dp+bMKbGmWZYro9PZ7X3ejo/J37hhrIRYCIj+u/xDq1Fstp9BVFQUpYrVpFSxmnEum9HUnJqV21Kzcts45993vIht4SqULVEvzvni00lTh29Ah7JVqG1djO23ryRJ+Vedn6Kvr8fQOk2SpHzxbahYxQobWwuuX3ZLkvI93wbj/jqQNh2LJEn54tuQq0ZVspYozuv/LidJ+T5PnNDT06NQy2ZJUr74NtSp1pEytnU4c2n7Z5cREOjDtTtHGfjr4kSMTKSaxDciIoJZs2Yxd+5cxowZw4MHMnTHp5jX+kf8QoK54+qcqOU+93rDxeeP2fBjX4wMpEORiF/HLkUJDo6I9da1LxXgH8b1y+70GlCa9OnlQZWIX/EeXQkPCsLv+YtELTfI4w3eDx9Rdkh/9A3leiji16/bPIKCfHF6cfuT1w0LD+HgyX8Y2W8N2S2kLXliSjV/QWbOnImlpSW9e/fGx8eHDh06sGPHDjJn/vg4dyL60Uqvaon/KKSARXYG1W6c6OWKb5O+vh616+f9+IKfyCyjsTb0mRAfo6evT/73OrElhgyW2SnYommilyu+Tfr6+jT/rvdnrWtslI6OLUckckQCUskdXy8vL+zs7GjevDkAWbJkoUCBAmzdujWFIxNCCCGEEN+KVJH4Xrp0CYBcuXJp06ytrbl48WJKhSSEEEIIIb4xqaKpw+vXr8mcOTN6enraNDMzM9zc4u8kExoa+uVtgTsk/uMw8XXxSQXtyZvVW5rSIYgUlhr6NSyoWielQxApLDXUwxK1Pr6M+LY9eOD9ReuHhsZ+eUiMVJH46unpke7/330eIyoqCkPD+MMrW7ZsEkYlhBBCCCG+JamiqYOVlRW+vrpvOPHz8yNHjtivkBRCCCGEEOJzpIrEt2rVqoSFheHu7q5Ne/HiBTVrxj3gsxBCCCGEEJ8qVSS+FhYWtG3blhMnTgDg7e3N06dPad++fQpHJoQQQgghvhV6SimV0kEABAUFMXv2bLJnz467uzs//vgjxYoVS+mwhBBCCCHENyLVJL5CCCGEEEIkpVTR1EEIIYQQQoikJonvN+bWrVv069ePxYsXp3QoIo2SOii+Fo8fP2bUqFFMmDDhg8v07duXNWvWJOp27969y4ABA+QcEamGr68vixYtom3btikdSpJLFeP4pmU3b95kwYIFXLp0iSZNmmBgYMCzZ8/o0qUL33///SeXZ25ujqOjI8WLF0+CaHVFREQwa9Ys9u7di5GRER06dGDQoEE6LyKJERkZSb169XRG7gDo2bMnI0eOTPJYxYd9zXUwKiqKuXPnsn37dtKlS0e/fv348ccf411n6tSpbNq0CYB06dJx6tQpLCwskjxWkTA+Pj6sXr0ab29v7cVGBgYGeHh40L9/f/LkyZNo28qQIQPOzs4UKFDgg8v88MMPOm8VTQyZMmXi/v37FC1aNFHLFV8uKCiIiRMn8tdff6V0KMkqMjKSgICAWEPLfosk8U1h5cqVo1mzZly5coW///4bgIMHDzJ06FDSp09Ps2bNPlrGzZs3CQ8Pp3LlyuTPn5+cOXMmcdTR1q9fT+7cuVm/fj3nzp3jr7/+wtzcnG7dusVa9syZM/zwww9Ur14dAwMDAObNm0fjxo2TJVbxYV9zHdy7dy916tShX79+rFy5kilTplCzZk3y5csX5/IeHh5ERESwdu1aADJnzixJbyry8uVLunfvzqhRo3SuDS4uLnTt2pX+/fsn6vZy5879wboSo27duom6TYB8+fJhZWWV6OWKL7d7924OHDjAoEGDyJ8/f0qH81n2799P2bJlP+lHooWFBYULF+bYsWNJGFnqIE0dUoH331DXtGlTMmbMyP79+z+67qtXrxgxYgTv9lHU10+er7Vw4cL8/PPPFCtWjF69etGoUSMuXLgQ57JFixblt99+o2zZspQqVYqiRYvi4+ND6dKlkyVWEb+vtQ42btyYKlWqkDFjRvr16/fRba9atYoyZcpQvnx5qlevTokSJZIlTpEwI0aMoHz58rF+EOfNm5fx48cnyTaTq66+L+YGgEg9lFKcO3eObNmysXnz5pQO57M8ePCAqVOnfta6aaVOyh3fVEhPT4+oqCjMzMw4ceIEw4cPp0iRIixYsIBcuXLx8OFDevbsyfz587l58yYvX75kx44dPHnyhC5dugDRJ/DixYvZsmUL+fPnZ9WqVZiamgJw9OhRbt68CUS3NRs5ciSlS5fmzp07/PPPP2TKlImSJUuyYsUKTExMWLNmTZyP+urUqaPzOW/evAQGBsa5T7lz59b5fPbsWWrVkheyp1ZfSx1Mnz699u+HDx/y22+/ffAuR0BAACdOnGDjxo1MmTKFoUOH0q1btzib5ojkd/v2bW7evEnPnj3jnP/dd98REREBgJubG6tXr8bMzIw7d+5QtWpVevXqhaenJxs2bGDHjh1s2rSJadOmcfPmTYYPH06FChWYNm0a9+7do1+/fvTu3Vun/Hnz5rFp0yasra2ZOXMm1tbWnDlzhg0bNlCuXDkGDBjAgQMH2LBhA+3atePx48fs27ePsmXLsnTpUgwMDIiMjMTOzo7AwEBOnz5NmTJlGD16NPr6+gQEBDBr1iyyZcuGm5sbr169SvJjKj7N2bNnqVmzJsWLF2fjxo0MGTKEDBky6Czj6OiIvb091tbW2NnZoa+vT/78+Zk+fTomJiYsWbKE7Nmz8+TJE06dOkXhwoVp1qwZUVFRbN26lWbNmnHo0CGCgoLYs2cP169f5/Llyzx79gw3NzemT5+uPYXYvHkz4eHhBAQEsGvXLgoWLEitWrX4+eefWblyJX5+foSEhPDgwQPmz59PhgwZsLe3x8fHh7Vr11K2bFlatmwZ7za2bdvG/fv3yZAhA7du3UruQ54ylEhxO3fuVLa2ttrnLVu2qGLFiqmrV68qpZRavHixatGihTb/+fPnas6cOdpnGxsbdenSJe1z165dVY8ePZSrq6vy8/NTVatWVbt27VJKKXX16lXVpUsXbdndu3erChUqKE9PTxUREaF69+6t2rRpo27fvq3Cw8NVixYt1Lx58xK0H127dlVPnjxJ0LLDhg1TDx48SNCyIul9zXXQ399fbdq0SdWqVUstXLhQRUVFxbuvXl5eauHChcrW1lYtWbIkgUdIJLWNGzcqGxsb9fDhw3iXCwsLU82bN1fPnz9XSinl5+enKlWqpLZu3arCw8PVvn37lI2NjTp9+rSKjIxUS5cuVeXLl1cHDhxQERER6uDBg6p48eIqKChIKaXU6NGjVatWrdT169eVk5OTateunWrRooWKjIxUoaGhqmnTpmrhwoVKKaVCQ0NVhQoV1MCBA5WHh4dyc3NTtra26vz580oppdauXavOnTunlFLK29tblS5dWv37779Kqehr3rZt25RSSgUHB6tKlSpp5YrUYciQISogIEC5u7urEiVKKDs7O535UVFRql69eur27dtKKaUOHTqkypQpo0JDQ5VS0dfRnj17asu3aNFCu8b4+fmpChUqqP79+6unT5+qXbt2qdevX6vx48dryw8ePFh16tRJKaXUpUuXVNOmTbV5vXv3VuPGjVNKKfXo0SNVvHhx7VrXpEkTtXr1aqWUUi4uLsrGxka5uLgopVS82zh37pzq3LmzNm/ixImqXr16n338vhbS1CGVUEqxadMm/v77b+7evcvWrVupWLEiAN26dcPV1ZUzZ84AsH37djp16hRveeXKlSNnzpxkzJiRAgUK4ObmBsDatWupUKGCtlzLli3R09Nj165dGBgYkCVLFooWLUrp0qUxNDSkaNGieHh4fDT+8+fPU6tWLaytrT+6bGhoKM+fP5cXlKQyX2sdTJcuHRUrVqRt27YsWbKE9evXxxuXubk5AwcOZOzYsaxatYqoqKgEHR+RtGKeFr3f7OZ9Z86cwdfXV2t/mTFjRlq2bMmGDRswNDQkW7ZsQPQTKX19fcqWLUtAQADNmjXDwMCAkiVLEhERgbe3t1amra0t5cuXp1ChQvz+++88evQIFxcXjI2NddqAGxsbkzFjRurWrUv27NnJkSMH2bJl482bNwD8+++/ODo6sm7dOuzt7alZsyYBAQE4Oztz4MABvvvuOyC6zkrHttTFyckJKysrTE1NsbS0pGHDhtjZ2eks4+3tzatXrzAxMQGgSJEiBAcHExwcDICDgwPp0qXTli9cuDBeXl5AdD3NmDEj9erVo2DBgrRt25a9e/fi7+/PunXrWLduHRYWFmTKlImoqKhYZRUpUkQrq0CBAqxduxalFOfPnyc8PJygoKA49yu+bSxbtkyrkwBly5b98gP5FZCmDqmEnp4eXbt2jXNexowZ+fHHH1mxYgXVqlXD3d2dvHnzJrhsQ0NDIiMjAXj69KlOg30DAwPy5MmjJSXvP/Y1NDTUabsZF3d3dy5evJjg0RnOnDkTq5mESHlfax2MSY5jEuT//vuPn3/++aMx/fjjj/z11194e3uTNWvWBO+LSBoxP5pdXFzi/QH99OlTrclDjPz587N7924gdv15vw1vzPwP/eCxsbEBopOc/PnzxyovrvoZU5arqyvNmzfXOq7F1MOjR4+ilNKa+ojUZ/PmzURERDB37lwgut48evSIS5cuUbVqVSC6A1iJEiU4e/YsRYsW5cWLF9SsWZPMmTMDUKtWLSZMmEBgYCCmpqa4uLjw008/advQ09PTqT+urq4ULVo0zutVtWrVWLJkCa9fvyZnzpy8ePGCFi1aAGBkZISvry8zZsygXbt25MyZ84PXyPi28eDBA1q1avVZx+trJnd8vxI///wz9+7d488//6RRo0afvH7MSZE7d24eP34ca35C7tTGxdfXl82bNzN06NAEr3Po0CGaN2/+WdsTKSe11sF3lSxZ8pOGnsqbN6+M6pBK1KpVC0tLS/bs2RPnfH9/f5ycnMiTJw/e3t68fftWZ37hwoUTJQ5fX18MDQ0pWLDgJ69raWnJvn37dKZdvXqVjBkzAvDkyZNEiVEkLj8/P/z8/JgyZQojRoxgxIgR/PXXX9jY2GhDH8aYPn261s7X3d1dZyzm+vXr06JFCzZv3syOHTsYO3Ys5cuX/+B2LS0tOXTokHZTAODatWsopShRogS9evVi165d2Nvb8/3332t/N69cucLcuXMZO3Ystra28e5bfNvImDFjnNfib50kvqlAZGQkUVFR8T5yzZo1K+3bt+fEiRPUq1dPZ56RkRE+Pj7aRVUpFevXX8znn376if/++4/nz58D4OXlhb+/Py1bttRi+dC67/P29mbmzJm0bt0aNzc3nJ2d2b59u3YirVmzhuvXr+usExwcjKura6IkOSLxfK118OHDh9q4k5GRkVy4cIEePXpo89+tgw8fPuTw4cNabIsXL2bcuHHSuS2VMDExYe7cuZw4cYJVq1bp/KH28vJiy5YtFCxYkAYNGpArVy6dx9DXr1/XvveYuvKxOvTu53cfE9vb29O9e3ftLt77dTm++tm2bVsWLFjA4sWLuXr1KvPnz0cpRdmyZbGysuKvv/4iNDSUoKAg3r59i6enJ+Hh4Z9+sESisrOzo127drGmd+rUiZMnT/LixQtt2vjx4+nYsSMlSpSgcuXKhISEaPOOHz+Op6cnderUoWzZslhaWsZ6OvFuvW7evDnPnz+nT58+nD17loMHD3Lu3Dn09PS4e/cuV69epUGDBpQsWZKCBQsSFhYGwL179wgMDMTf35/Hjx/j6upKSEgIL168wNjYGEC7Hse3jaZNm7Jr1y4ePnwIRD9t8fPz+2CziW+FNHVIYdeuXWPfvn0opVi1ahXNmzf/YK/0li1bkjlz5lht4Dp27MjUqVMZPXo07u7uPH78mKioKJo2bYqXl5f2aLB169bUqVOH33//nTFjxlC5cmX8/f1Zvnw5ZmZmPHjwgNu3b6Ovr8+dO3cwMDDAwcGBiIgI7t+/r/NCAl9fX7p06YKTkxO7du3SpltbW3Pw4EEADhw4gIGBgU57ztOnTyfJuJji832tdRBg4cKFXL9+nbp162JhYUH//v11mlG8Wwdfv37NH3/8weLFiylVqhSdOnVKM23avhZVqlRhx44dLF68mHbt2pE/f34sLS3JkycPv/zyC/r6+piYmLBq1SomT57MxIkTyZQpE9WrV6dp06b4+Pho159t27ZRv359Dh06BEQnN02aNGH79u1AdILbq1cvunbtyt9//82gQYOwsbEhU6ZM9OrVC4g+Nx4/fkxkZCStWrXiyZMnvHnzhtOnT1O5cmUcHR15+/Ytp06dokaNGvTq1YvAwEDs7OzYvn07AwcOpHLlygAsW7aMCRMm0KxZM7777juyZctGcHAwTk5O0t8hBdnb27NixQp+/fVXSpQoof3g8fLy4smTJ0RGRjJy5EjGjh1LuXLlsLS0ZPDgwfj7+2s/Wn788Ud+//13smXLxvnz5zl58iQhISFERUWRLVs21q5dy5MnT/Dw8GDv3r2UK1eOwoULkz9/fpYtW8asWbMYOnQo9erV448//gCim5c5OTnRpUsXgoODiYyMxNTUlCVLltC0aVN27NhBy5Yt+eWXX6hduzbHjx+ndevW5M+fn/r16zN48GCmTJlCjRo1PriNwYMH4+fnR/fu3alcuTI5cuSgYMGCHD16lDZt2qTI95Ec9NTHGnCKVGPu3Ll07dpVBj4XKUbqoBAirXJ1dWXLli0MHz5cmxYQEMDs2bOZMmUKixYtolWrVtqP74iICBwdHbl69WqC+h28a/v27eTLl48qVaoA0XeK3dzc2LZt2yc1LRSxSVOHVM7Ly0vrIRwUFCQJh0h2UgeFEAKWL1/Oq1evtNEVILp5QKFChfDw8OCff/7B1dVVa/oSHh7Of//9R4MGDT5pO5GRkUyfPh1PT0+tqURUVBQXLlygfv36ibdDaZTc8U3lbt26xa+//kqVKlWYPXs2ZmZmKR2SSGOkDgohBDg7O/P3339z+fJl9PT0yJkzJ82aNaN79+7o6+tjZ2fHli1bcHNzw8LCgmLFijFw4MDP6nh56NAh1qxZw4sXL8iUKRPW1tb06dMn3s5yImEk8RVCCCGEEGmCNHUQQgghhBBpgiS+QgghUkxISAj37t3jzJkz/PTTT9qLKFKLY8eOsWjRIpo0acLSpUuTZZt37tyRNwp+45RSHD16lHbt2nH58uWUDidNkcRXCCFEinjz5g2rVq2iSJEi5MiRgzt37nz0TZHJydHRkW3btjFw4EBmzpzJnj17kiW+PHnyMGfOnG9+PNW0LmPGjNy7dy+lw0hzJPEVQgiR7CIiIpgwYQK//PILxsbGFCtWDHNz80TdRkBAQKw3b32KQ4cOaTGVLVuWI0eOxHrhyYoVK74oxrhYWFjQpk0bfv/990QvW6QOenp62hjPCfGldfljkqIep1aS+AohhEh2mzdvpmjRopiammrT9PUT709SSEgIw4cPx9vb+7PL8PDwiDemJUuWcP78+c8uPz5FixYlNDSU//77L0nKFynPwMAgQcslRl2Oz+7du9m2bVuSlJ0ayZvbhBBCJLv169czY8aMWNP9/f3p168fly9fpnbt2kybNg0zMzMiIyOxs7MjMDCQ06dPU6ZMGUaPHo2+vj5bt24lICCAV69eYW9vz82bNzl69CiPHj0iICCAiIgIfvvtN0xMTHS25ebmxurVqzEzM+POnTtUrVpVe2vbkiVLcHBwAKJf3NK8eXNsbW21dW/cuMF///2Hq6sr8+fPp1mzZowaNQovLy+2bt2Kp6cnQ4cOJUOGDPz9999YW1uzbNkyrly5wsKFCzE1NeWff/4hODgYNzc3AgICtLd/xahevTpr166levXqSfEViA/Yv38/W7ZsoWXLlly9epWTJ09StWpVZs+eTYYMGeKshzdu3GDDhg1kypQJQ0NDDh06xM6dO2O9BdPJyYnly5eTL18+Xr9+rTPvzp072qu5jx49yq+//krTpk3jrMuXLl3i+PHj5MiRg5MnTzJ27FgqVapEVFQUf//9N+bm5ly+fJnw8HBWr14NwMmTJ3n8+DG3bt0CYPr06Xh5eXHkyBF8fX2ZP38+devWpVy5cslynFOMEkIIIZLR48ePlY2NjXrz5o3O9Hr16qlBgwapZ8+eqf/++09VrlxZ/fHHH0oppdauXavOnTunlFLK29tblS5dWv3777/K399fNWvWTCtjxowZ2r+7du2qFi5cGGcMYWFhqnnz5ur58+dKKaX8/PxUpUqV1NatW7VlRo8erUaPHv3B/Vi4cKHq2rWr9vm///5TZcuWVcHBwUoppTZv3qwaN26szV+zZo16+fKlUkqppUuXqvnz52vzxowZozp16qRT/sWLF1XJkiW18kTyCAgIUJUrV1YDBw5Ubm5u6vbt26ps2bJq6tSpH6yHoaGh6pdfflFNmjRRT548UZs2bYr1vYWGhqpGjRopJycnpZRSN2/eVDY2NurSpUtKKaXatWundu/erZRSasWKFapFixbauu/X5SpVqqirV68qpZSaNGmS6tOnj1JKqdOnT6uJEycqpZSKjIxUs2bNUkop5eDgoObNm6eUUioqKkp17NhRDRs2TCml1M6dO1W9evUS7wCmctLUQQghRLJ6+vQpQJxteuvUqUOBAgWoVq0aPXv25Pjx4wD8+++/ODo6am8RrFmzJgEBARgaGvL69WtGjhyJi4sLv/76a4JiOHPmDL6+vtrrZTNmzEjLli3ZsGHDZ+9X1apVyZIlC8eOHQOie+67urpy/fp1ANzd3cmdOzdRUVGsW7eOSpUqaet26dKFmzdvcufOHW1atmzZCAsL49WrV58dk/h0pqammJqaUrduXXLkyEHp0qVp06YNx48f/2A9NDY2Jlu2bJQuXRpra2u6dOlCunTpdMrdu3cvxsbGFCpUCIhuN/6uSZMm8d133+Hs7Mzjx48JDAz8YIwLFy6kdOnSPHz4kJcvX2rLmpqasnv3bpYsWUJQUBA9evQAol+B7O3tzbp161i/fj3W1tYYGqbNh/5pc6+FEEKkmNDQUPT09D7axtHGxkZr1+jq6krz5s21V2b//PPP2nJr165l0qRJNGnShC5dujB69OiPlv306VPtdbAx8ufP/0XDqenp6dGmTRvs7e1p1qwZ7u7uNGrUiB07dmBiYkLJkiWB6NeA+/j46Gy/QIECQHTzi9KlSwNgbGwMRHdsEinLxsYGe3t7vL29P1gP3+/4+L6HDx/qtGl/X/bs2fnrr7+oUKECFStW1H4wxSVz5sxMnz6dunXrUrp0aa5duwZAxYoVmTp1KnPmzGHdunWMHTuWdu3a4erqSosWLWjduvUn7PW3Se74CiGESFYWFhYopT46XJefnx9FihQBwNLSkn379unMv3r1KsHBweTMmZPdu3fzxx9/sGXLFvbs2fPRGPLkyYO3tzdv377Vmf45r5d9V9u2bbl06RIbN26kUaNGtG/fnsOHD7Nnzx4aNmwIRO9/hgwZePToUaz1ra2ttX+HhIQAkCVLli+KSXy5sLAwChYs+MF6mBBmZmY8f/6c8PDwWPOUUnTr1o3mzZvTokULjIyMPliOv78/Xbt2pV+/ftSrV0+nA6azszOtW7fm6NGjtGnThvHjx+Pi4oKlpSX79+//rLi/NZL4CiGESFbFixdHX18/VucegODgYCA6Edi7dy8DBw4EohPKBQsWsHjxYq5evcr8+fNRShEQEMC6devQ19enffv21KlTRxtr19jYGB8fH968eYOPj4/Odho0aECuXLmws7PTpl2/fl17NAzRQ67FlaTEiCk/MjJSa76RL18+ypUrx+nTpylZsiRVqlQhW7ZsREREaJ3r9PX16dKlCzt27CAsLEzbdp06dXQSXw8PDzJmzEjevHkTfGxF4vHw8ND+ffHiRX7++ecP1sMYkZGRHyyvcePG+Pr6smzZMgBcXFwA8PT0xMvLCxcXF9zc3AgMDOT69euEhITg4uJCZGSkTl12dnbGz8+P169f4+XlhYODAyEhIbx48QIHBwfOnj2Lqakp48ePJ1OmTED0+XP27FlGjhzJxYsX2b59uzaGsLGxMf7+/kRERPDkyZNEP46pjTR1EEIIkazMzc2pVKkSjx490kn0RowYwYYNG3B0dCRjxox069aNWrVqAdCrVy8CAwOxs7Nj+/btDBw4kMqVK/PmzRvWrFnD27dvsbGxIVeuXNrj3FatWjF9+nRMTEwYNWqUTgwmJiasWrWKyZMnM3HiRDJlykT16tVp2rQpEN0G+NKlS+jr63Py5EmqVatG+vTpdcpo0KABmzZtol+/fsydO1eb3q5dO+0urZ6eHt9//z01atTQWXfw4MGEhITQt29fypQpQ2BgIH/99ZfOMo6OjjRs2DBRh3kTCXfjxg3Wrl2Lj48P5cuXp2XLlkRERMRZD+/cucPNmzcJDAzkv//+i3MkDltbW2bNmsXff//NmTNnaNOmDVmzZuXBgwdUqVKFH374gUmTJlG7dm1atGjBoUOHOHnyJN27d9epy8OHD6d+/fr07t2bpk2b0qhRI2bPnq0lskOHDqVTp06kS5eOQYMGkTdvXvLmzcvs2bNZvHgxZ86coVWrVowZMwaAKlWqkDVrVrp27RqrDn6L9JRKRa/JEUIIkSZcunQJe3t7Zs6cmdKhpFo9evRg4sSJWmcokXzq16/PgAEDaNeuXUqHIhKZ/IwUQgiR7KpWrUq2bNm4f/9+SoeSKl28eJE6depI0ptClFKp6vXZIvFI4iuEECJFDB8+nDt37vDs2bOUDiVVuXfvHu7u7jojBojkERkZib29PW/evOHUqVNaO1zx7ZCmDkIIIVJUQEAAZmZmKR1GqiHHQ4ikI4mvEEIIIYRIE6SpgxBCCCGESBMk8U1DQkJCtOFO4nLr1q3kC0akWSEhISxbtoyffvopzrdkBQcH8/DhwxSITKQlcj0UqUFc9fDixYt069aN3bt3y/UwCUjim0a8efOGVatWaW9BiouBgQErV65MxqhEWhNTD+vVq8edO3fi7DWdPn163rx5w/bt21MgQpEWyPVQpAYfqodZs2bl9u3bKKXkepgEJPFNAyIiIpgwYQK//PKL9u73uJQqVQozMzO2bt2ajNGJtOLdelisWDHMzc0/uGytWrVwdnbmzJkzyRihSAvkeihSg/jqoY2Njc5rquV6mLgk8U0DNm/eTNGiRTE1Nf3osp06ddLeVCNEYnq/Hn7sbVQ9e/bkzz//jPeVsUJ8KrkeitTgY/XQwMBA57NcDxOPJL5pwPr163Vel7ly5Urmzp3LtGnT6NKli877yA0MDChRooQ8VhGJ7v16CODv70+/fv0oX748Q4YMISAgQJuXOXNmsmTJwrFjx5I7VPENe78euri4MH/+fObPn0/79u05f/68Nk+uhyKpvF8PPTw8GDNmDIsWLWLs2LE610KQ62FiksT3G/fkyRNevXqFtbU1AI8fP2bBggUMHz6cCRMm4OXlxf79+3XWKVCggDxSEYnq/XoY48aNG4wePZolS5Zw8eJF5s2bpzNf6qJITO/Xw5CQEEaMGEGvXr0YOnQoFSpUYOrUqTrrSB0UiS2u6+HgwYNp3bo1AwcOZMiQIfj7+8daT+pi4pDE9xv39OlTAK09ZYECBVi7di1KKc6fP094eDhBQUE662TNmlXepCQS1fv1MEadOnUoUKAA1apVo2fPnhw/flxnvtRFkZjer4enTp0ie/bs2ssihg0bxoYNG3TWkTooEtv79fDixYs4OjpSrVo1AHLkyEHOnDljrSd1MXFI4vuNCw0NRU9PT2svZGRkhK+vLzNmzCBr1qzkzJkzVs96Y2PjOH9tCvG53q+HcbGxscHb21tnmtRFkZjer4cvX74kLCxMm29iYkKOHDl01pE6KBLb+/Xw4cOHZMiQ4aPrSV1MHJL4fuMsLCxQSml3da9cucLcuXMZO3Ystra2ca4TGhqq06NUiC/1fj2Mi5+fX6xhfaQuisT0fj20srLi2rVr+Pn5acvcuHFDJxmWOigS2/v10MzMDE9Pz1g//N8ndTFxSOL7jStevDj6+vq8fv0agHv37hEYGIi/vz+PHz/G1dWVkJAQXrx4oa3j4eFB8eLFUypk8Q16vx7GCA4OBkApxd69exk4cKDOfA8PD0qUKJFscYpv2/v1sG7duhgbGzNgwACuXbvG0aNHOXnypM7wUnI9FInt/XpYp04d0qVLx+zZs4mKisLLy4vAwEA8PT11RnGQ62HikMT3G2dubk6lSpV49OgRAE2bNiVz5sy0bNmSCxcuULt2bY4fP05oaKi2jqOjI02aNEmpkMU36P16CDBixAj27dvHpEmTmDt3Lt26daNevXo66zk6OtK4cePkDld8o96vhxkzZmTlypUEBATQp08fjhw5Qt++fXXWkeuhSGzv10NLS0uWLFnCrVu3aNmyJXZ2dmTPnp3Xr1/j5uamrSfXw8Shp+J6dZL4ply6dAl7e3tmzpz50WUDAwP58ccf2bFjB0ZGRskQnUgrPqUeQvQwU+PGjWPjxo1JHJlIS+R6KFIDuR6mHLnjmwZUrVqVbNmycf/+/Y8uu3HjRn7//Xe5yItE9yn1EKLr4rRp05I4KpHWyPVQpAZyPUw5csc3jVBK8e+//1KlShUKFiwY5zInTpzAzMyMKlWqJHN0Iq1ISD1USrFnzx6KFi36wQ6YQnwJuR6K1ECuhylDEt80JiAgQBuz8lPmCZGY4qtrMT3q339/vRCJTa6HIjWQ62HyksRXCCGEEEKkCdLGVwghhBBCpAmS+AohhBBCiDTBMKUDEEIIkfT8/f1Zv349Tk5OuLi4MHfuXAoUKJDSYQkhRLKSNr5CCPGZFi1axP79+ylTpgwhISEcOXKE2rVrY2FhgaOjI7ly5WLp0qUpHSYAQ4YMoVu3bpQvX55BgwZRvXp1fvjhh5QOSwghkpXc8RVCiM+ULVs27O3tSZ8+PS9fvuTIkSP06dOHihUrEh4ezpo1a1I6RABCQ0M5fvw4w4cPB2DhwoUpHJEQQqQMaeMrhBCfqXHjxqRPnz7OeUZGRrRv3z6ZI4qbl5cX4eHh6OnppXQoQgiRoiTxFUKIz2RhYRHv/OPHj2Nra0ufPn3w9vYG4Pz589SvX5+rV6+ycOFCatWqxb1792jatCnVqlVj/fr12vpubm4sXryYGTNm0LZtW86dO/fBbf3777/MmzePKVOm8Ouvv/L8+XMAbt68yfLlywFYtWoVq1ev1lkvPDyczZs307JlS+zt7WnWrBl9+/Zl/vz5FC1alJcvXxIQEMDixYu1z0+ePGHcuHH06tWL48eP06RJE2rXrp3gt1AJIURKkcRXCCGSSKdOnWjbti16enqYm5sDoK+vT69evShfvjyFCxfGw8ODR48esWPHDjp27MiMGTNwcHAgKiqK6dOn07t3b8aOHUuHDh0YPHiwlkC/a+/evVy7do1hw4YxadIkypUrx6+//kpYWBjlypWjV69eAPTq1Ytff/1VZ11DQ0Pq1avHo0ePcHBwYN68ebRr144OHTpoy5iZmdGmTRvtc8GCBUmXLh3Pnj0jffr0HDp0CBsbm1hJtRBCpDaS+AohRBLq06cP586d4/HjxwDs27ePli1bYmBgQNasWQFo27Ytpqam9O/fn0yZMnHy5EkcHBx4+fIldnZ2rFu3jjdv3lCuXDnc3d1jbWPNmjVUqlRJ+9ylSxdevnzJiRMnPhqfnp4eOXPmBKBhw4YUK1aMRo0axbuOgYEBWbJkIWfOnNSoUQM9PT1KlCjBmzdvEnxchBAiJUjnNiGESEL58+encePGrFixgjFjxpAhQ4YPvp7U2NiYAgUK4Ofnx6tXr8icOTM///zzR7fx9OlTwsPDtc/m5uZkzpwZNze3BMUY0/b3U9oAv7+soaEhMkiQECK1k8RXCCGSWO/evfn+++9Jnz49nTt3jnfZsLAwChYsiKWlJTdu3MDV1ZVcuXIB8PbtW/z9/SlYsKDOOrlz59buKL/L2tr6s2M2MDAAICoq6rPLEEKI1EaaOgghRCKISRAjIyNjzStWrBi1atXi4cOHFC9ePNb8mOYLHh4eeHl50apVK8qUKUPu3Lnp0aMHBw8e5MKFC/z111/kyZMn1vrdunXj4MGDWvvfx48fY2VlRY0aNXRiioiISNA+QPRdY0NDQ65du0ZAQAD79+8HopPvyMhIIiMjY93hlTu+QojUTu74CiHEF3r27BmbN28GYNu2bWTOnJlixYrpLNOyZUtCQkLiXH/Lli2Ym5vz6NEjFi9eTKZMmQBYsWIFkyZNYvz48RQrVow///wTIyOjWOt37twZb29vBg4cSIUKFQgICGDVqlUYGBjg7u7O2rVrAdi8eTMdOnTAxsZGWzcyMpItW7YAsHXrVvLly0fu3LlJly4dQ4cOZerUqRw4cIABAwaQO3duLl26RPr06bl48SIvXrzg4sWLWFpacuXKFR4/fszVq1d12hsLIURqIm9uE0KIZDBx4kTGjx9PunTptGmXL1+mW7duODo6pmBkQgiRdsgdXyGESCIuLi6cOHECExMTrKysdJJe+F/TAKWUvFxCCCGSgbTxFUKIJHL//n0WLFjA3bt36dOnj848V1dXrd2snZ0dYWFhKRGiEEKkKdLUQQghhBBCpAlyx1cIIYQQQqQJkvgKIYQQQog0QRJfIYQQQgiRJkjiK4QQQggh0gRJfIUQQgghRJrwf7XFn9MramnPAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = list(range(len(temp_df)))\n",
    "plt.figure(figsize=(10,5))\n",
    "sns_plot = sns.barplot(x=bins, y='values', palette=\"husl\", data=temp_df)\n",
    "\n",
    "plt.xticks(bins, labels, rotation=0, fontsize=15)\n",
    "\n",
    "for v, rect in zip(values, sns_plot.patches):\n",
    "    height = rect.get_height()\n",
    "    plt.annotate(\n",
    "        str(v)+\"%\", xy=(\n",
    "            rect.get_x()+rect.get_width()/2-0.1, height+1), rotation=0, color=\"black\", size=14, weight='bold')\n",
    "    \n",
    "for t, rect in zip(totals, sns_plot.patches):\n",
    "    height = rect.get_height()\n",
    "    plt.annotate(\n",
    "        \"(\"+str(t)+\")\", xy=(\n",
    "            rect.get_x()+rect.get_width()/2-0.1, 1.5), rotation=0, color=\"black\", size=14, weight='bold')   \n",
    "\n",
    "plt.ylim(0,50)\n",
    "plt.xlabel(\"Type of run\", size=15)\n",
    "plt.ylabel(\"Success rate (%)\", size=15)\n",
    "plt.title(\"Execution success rate of datasets with Python code from Harvard Dataverse\", size=18)\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"all_success_rate.pdf\", dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[24.01, 22.92, 26.91, 43.96]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code in other languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_df['code'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(agg_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Success rate when `requirements.txt` was present"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = ((df['req'] == 1) & (df['result'] == 'success')).sum()\n",
    "count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = ((df['req'] == 1) & df['result'].notnull()).sum()\n",
    "total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success rate with requirements.txt 38.64\n"
     ]
    }
   ],
   "source": [
    "print(\"Success rate with requirements.txt \"+str((count*100./total).round(2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Success rate without datasets that have other code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = ((df['code'] == 0) & (df['result'] == 'success')).sum()\n",
    "count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "196"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = ((df['code'] == 0) & df['result'].notnull()).sum()\n",
    "total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success rate without datasets that have code in other languages 34.69\n"
     ]
    }
   ],
   "source": [
    "print(\"Success rate without datasets that have code in other languages \"+str((count*100./total).round(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count = ((df['code'] == 1) & (df['result'] == 'success')).sum()\n",
    "count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "183"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = ((df['code'] == 1) & df['result'].notnull()).sum()\n",
    "total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success rate in datasets that have code in other languages 18.58\n"
     ]
    }
   ],
   "source": [
    "print(\"Success rate in datasets that have code in other languages \"+str((count*100./total).round(2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggregate data per dataset\n",
    "agg_df = df.groupby(['doi']).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_autopct(values):\n",
    "    def my_autopct(pct):\n",
    "        total = sum(values)\n",
    "        val = int(round(pct*total/100.0))\n",
    "        return '{p:.2f}%  ({v:d})'.format(p=pct,v=val)\n",
    "    return my_autopct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anatrisovic/Desktop/python-study/analysis/env3/lib/python3.7/site-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  FutureWarning\n",
      "/Users/anatrisovic/Desktop/python-study/analysis/env3/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Cut the window in 2 parts\n",
    "f, (ax_box, ax_hist) = plt.subplots(2, sharex=True, gridspec_kw={\"height_ratios\": (.15, .85)})\n",
    " \n",
    "# Add a graph in each part\n",
    "sns.boxplot(agg_df[\"sizeMB\"], ax=ax_box, color=\"g\")\n",
    "sns.distplot(agg_df[\"sizeMB\"], ax=ax_hist, bins=80, kde=False, color=\"g\")\n",
    " \n",
    "# Remove x axis name for the boxplot\n",
    "ax_box.set(xlabel='')\n",
    "ax_box.set_title('Distribution of dataset sizes', fontsize=20)\n",
    "ax_hist.set(xlabel=\"Size in MB\")\n",
    "#plt.xscale('log')\n",
    "plt.xlim(0, 650)\n",
    "plt.show()\n",
    "\n",
    "f.tight_layout()\n",
    "f.savefig(\"ds_size.png\", dpi=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mean dataset size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "248.73152173913041"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_df['sizeMB'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1999.68"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_df['sizeMB'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_df['sizeMB'].min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>size</th>\n",
       "      <th>sizeMB</th>\n",
       "      <th>files_count</th>\n",
       "      <th>docs</th>\n",
       "      <th>code</th>\n",
       "      <th>docker</th>\n",
       "      <th>req</th>\n",
       "      <th>env</th>\n",
       "      <th>agg</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>doi</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>doi:10.7910/DVN/0OFNFY</th>\n",
       "      <td>11399985</td>\n",
       "      <td>11.40</td>\n",
       "      <td>59</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>doi:10.7910/DVN/1CSVBV</th>\n",
       "      <td>258929648</td>\n",
       "      <td>258.93</td>\n",
       "      <td>121</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>doi:10.7910/DVN/1JBNDC</th>\n",
       "      <td>50606409</td>\n",
       "      <td>50.61</td>\n",
       "      <td>131</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.071429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>doi:10.7910/DVN/2XSVWA</th>\n",
       "      <td>171740</td>\n",
       "      <td>0.17</td>\n",
       "      <td>13</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.600000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>doi:10.7910/DVN/2YYJ2B</th>\n",
       "      <td>61263478</td>\n",
       "      <td>61.26</td>\n",
       "      <td>12</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             size  sizeMB  files_count  docs  code  docker  \\\n",
       "doi                                                                          \n",
       "doi:10.7910/DVN/0OFNFY   11399985   11.40           59     1     0       0   \n",
       "doi:10.7910/DVN/1CSVBV  258929648  258.93          121     1     0       0   \n",
       "doi:10.7910/DVN/1JBNDC   50606409   50.61          131     1     1       0   \n",
       "doi:10.7910/DVN/2XSVWA     171740    0.17           13     1     0       0   \n",
       "doi:10.7910/DVN/2YYJ2B   61263478   61.26           12     1     0       0   \n",
       "\n",
       "                        req  env       agg  \n",
       "doi                                         \n",
       "doi:10.7910/DVN/0OFNFY    0    0  0.000000  \n",
       "doi:10.7910/DVN/1CSVBV    0    0  0.250000  \n",
       "doi:10.7910/DVN/1JBNDC    0    0  0.071429  \n",
       "doi:10.7910/DVN/2XSVWA    0    0  0.600000  \n",
       "doi:10.7910/DVN/2YYJ2B    0    0  0.000000  "
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(agg_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Count of other files in datasets')"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "docs = (agg_df['docs'] == 1).sum()\n",
    "code = (agg_df['code'] == 1).sum()\n",
    "docker = (agg_df['docker'] == 1).sum()\n",
    "req = (agg_df['req'] == 1).sum()\n",
    "env = (agg_df['env'] == 1).sum()\n",
    "\n",
    "values = [docs, code, req, env, docker]\n",
    "temp_df = pd.DataFrame (values, columns=['values'])\n",
    "labels = [\"documentation\", \"code in \\nother languages\", \"requirements.txt\", \"environment.yml\", \"Dockerfile\"]\n",
    "bins = list(range(len(values)))\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "ax = sns.barplot(x=bins, y=values, data=temp_df)\n",
    "plt.xticks(bins, labels, rotation=0, fontsize=15)\n",
    "plt.xlabel(\"File(s) present in dataset\", size=15)\n",
    "plt.ylabel(\"Count\", size=15)\n",
    "plt.title(\"Count of other files in datasets\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[57, 46, 6, 0, 0]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# counts\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pie chart\n",
    "labels = ['Yes',  'No']\n",
    "sizes = [(agg_df['docs'] == 1).sum(), (agg_df['docs'] == 0).sum()]\n",
    " \n",
    "fig1, ax1 = plt.subplots()\n",
    "plt.rcParams['font.size'] = 15\n",
    "ax1.pie(\n",
    "    sizes, labels=labels, autopct=make_autopct(sizes), startangle=100,  textprops={'fontsize': 14}, wedgeprops={'alpha':0.7})\n",
    "\n",
    "#draw circle\n",
    "centre_circle = plt.Circle((0,0),0.70,fc='white')\n",
    "\n",
    "fig = plt.gcf()\n",
    "fig.gca().add_artist(centre_circle)\n",
    "\n",
    "# Equal aspect ratio ensures that pie is drawn as a circle\n",
    "ax1.axis('equal')  \n",
    "plt.title(\"Packages contain documentation \\n(readme, codebook or instructions file)?\", size=20)\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()\n",
    "fig.savefig(\"docs.png\", dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env3",
   "language": "python",
   "name": "env3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
